package service

import (
	"fmt"
	"sync"
	"time"

	"joylink.club/bj-rtsts-server/db/dbquery"
	"joylink.club/bj-rtsts-server/db/model"
	"joylink.club/bj-rtsts-server/dto"
	"joylink.club/bj-rtsts-server/sys_error"
)

var publishMapMutex sync.Mutex

// 查找发布地图分页信息
func PageQueryPublished(req *dto.PagePublishedReqDto) *dto.PageDto {
	p, pv, u := dbquery.Published, dbquery.PublishedVersion, dbquery.User
	where := p.
		Select(
			p.ID, p.Code.As("name"), p.Type, p.Category, p.Status,
			pv.Note, pv.PublishAt, pv.Version, u.Name.As("publisher"),
		).
		LeftJoin(pv, p.DataID.EqCol(pv.ID)).
		LeftJoin(u, pv.UserID.EqCol(u.ID)).
		Order(p.Status.Desc(), pv.PublishAt.Desc())
	if req.Name != "" {
		where = where.Where(p.Code.Like(fmt.Sprintf("%%%s%%", req.Name)))
	}
	if req.Release {
		where = where.Where(p.Status.Eq(1))
	}
	var records []*dto.PublishedDto
	count, err := where.Debug().ScanByPage(&records, req.Offset(), req.Size)
	if err != nil {
		panic(sys_error.New("查询发布地图信息失败", err))
	}
	return &dto.PageDto{Total: int(count), PageQueryDto: req.PageQueryDto, Records: records}
}

// 地图信息列表信息
func ListQueryPublished(req *dto.PublishedListReqDto) []*dto.PublishedDto {
	p := dbquery.Published
	where := p.Select(p.ID, p.Code.As("name"), p.Type, p.Category).Where(p.Status.Eq(1))
	if req.Name != "" {
		where = where.Where(dbquery.Published.Code.Like(fmt.Sprintf("%%%s%%", req.Name)))
	}
	if req.Type != 0 {
		where = where.Where(dbquery.Published.Type.Eq(req.Type))
	}
	if req.Category != "" {
		where = where.Where(dbquery.Published.Category.Eq(req.Category))
	}
	var records []*dto.PublishedDto
	err := where.Debug().Scan(&records)
	if err != nil {
		panic(sys_error.New("查询发布地图信息失败", err))
	}
	return records
}

// 项目启动时查询发布地图信息
func ListAllPublished() []*dto.PublishedDto {
	p, pv := dbquery.Published, dbquery.PublishedVersion
	where := p.Select(p.ID, p.Code.As("name"), p.Type, p.Category, pv.Proto, pv.Version).
		LeftJoin(pv, p.DataID.EqCol(pv.ID)).
		Where(p.Status.Eq(1), p.Type.Neq(trainDataType)).Order(pv.PublishAt)
	var records []*dto.PublishedDto
	err := where.Debug().Scan(&records)
	if err != nil {
		panic(sys_error.New("查询发布地图信息失败", err))
	}
	return records
}

// 查询详细信息
func GetPublishedById(id int32) *dto.PublishedDto {
	p, pv := dbquery.Published, dbquery.PublishedVersion
	where := p.Select(p.ID, p.Code.As("name"), p.Type, p.Category, pv.Proto, pv.Version).
		LeftJoin(pv, p.DataID.EqCol(pv.ID)).
		Where(p.ID.Eq(id), p.Status.Eq(1))
	var record dto.PublishedDto
	err := where.Debug().Scan(&record)
	if err != nil {
		panic(sys_error.New("查询发布地图信息失败", err))
	}
	return &record
}

// 草稿发布
func PublishFormDraft(req *dto.PublishReqDto, user *model.User) int32 {
	draft := QueryDrafting(req.DraftId)
	if draft.Proto == nil || len(draft.Proto) == 0 {
		panic(sys_error.New(fmt.Sprintf("草稿[%v]绘图数据信息为空", req.DraftId)))
	}
	return publishData(&dto.PublishedDto{
		Name:     req.Name,
		Proto:    draft.Proto,
		Type:     draft.Type,
		Category: draft.Category,
		UserID:   user.ID,
		Note:     req.Note,
	}, req.Force)
}

// 发布数据
func publishData(publishData *dto.PublishedDto, force bool) int32 {
	publishMapMutex.Lock()
	defer publishMapMutex.Unlock()
	p, pv := dbquery.Published, dbquery.PublishedVersion
	// 查询发布图数据
	oldPs, err1 := p.Where(p.Code.Eq(publishData.Name)).Find()
	if err1 != nil {
		panic(sys_error.New("发布草稿数据失败", err1))
	}
	var pid, version int32 = 0, 1
	if len(oldPs) > 0 { // 发布图数据不为空
		pid = oldPs[0].ID
		if oldPs[0].Category != publishData.Category || publishData.Type != oldPs[0].Type {
			if !force { // 非强制覆盖
				panic(sys_error.New("草稿数据与在线数据类型不一致"))
			} else {
				p.Where(p.ID.Eq(pid)).UpdateColumns(&model.Published{ID: pid, Type: publishData.Type, Category: publishData.Category})
			}
		}
		vds, _ := pv.Select(pv.Version).Where(pv.PublishID.Eq(pid)).Order(pv.Version.Desc()).Find()
		if len(vds) > 0 { // 版本号 + 1
			version = version + vds[0].Version
		}
	}
	// 存入新版本数据
	pvd := &model.PublishedVersion{
		Code:      publishData.Name,
		Proto:     publishData.Proto,
		UserID:    publishData.UserID,
		Note:      publishData.Note,
		Type:      publishData.Type,
		Category:  publishData.Category,
		PublishAt: time.Now(),
		Version:   version,
		PublishID: pid,
	}
	err2 := pv.Create(pvd)
	if err2 != nil {
		panic(sys_error.New("发布草稿数据失败", err2))
	}
	// 更新发布数据
	if pid == 0 {
		pd := &model.Published{
			Code:     publishData.Name,
			Type:     publishData.Type,
			Category: publishData.Category,
			DataID:   pvd.ID,
			Status:   1,
		}
		// 保存发布信息
		err4 := p.Create(pd)
		if err4 != nil {
			panic(sys_error.New("发布草稿数据失败", err4))
		}
		pid = pd.ID
		// 更新发布版本信息
		pv.Where(pv.ID.Eq(pvd.ID)).UpdateColumn(pv.PublishID, pd.ID)
	} else {
		// 更新发布信息
		p.Where(p.ID.Eq(pid)).UpdateColumn(p.DataID, pvd.ID)
	}
	return pid
}

// 删除发布数据
func DeletePublishedById(id int32) {
	dbquery.Published.Where(dbquery.Published.ID.Eq(id)).Delete()
	dbquery.PublishedVersion.Where(dbquery.PublishedVersion.PublishID.Eq(id)).Delete()
	dbquery.ProjectPublishLink.Where(dbquery.ProjectPublishLink.Mid.In(id)).Delete()
}

// 另存为草稿
func SaveAsDraftingFromPublish(id int32, user *model.User, name string) {
	num, _ := dbquery.Drafting.Where(dbquery.Drafting.Name.Eq(name)).Count()
	if num > 0 { // 处理重名情况
		panic(sys_error.New(fmt.Sprintf("草稿【%s】已存在", name)))
	}
	p, pv := dbquery.Published, dbquery.PublishedVersion
	where := p.Select(p.Type, p.Category, pv.Proto).LeftJoin(pv, p.DataID.EqCol(pv.ID)).Where(p.ID.Eq(id), p.Status.Eq(1))
	var record dto.PublishedDto
	err := where.Debug().Scan(&record)
	if err != nil {
		panic(sys_error.New("查询发布地图信息失败", err))
	}
	err1 := dbquery.Drafting.Save(&model.Drafting{
		Name:      name,
		Category:  record.Category,
		Proto:     record.Proto,
		CreatorID: user.ID,
		CreatedAt: time.Now(),
		UpdateAt:  time.Now(),
		Type:      record.Type,
	})
	if err1 != nil {
		panic(sys_error.New("保存草稿出错", err1))
	}
}

// 查询项目关联的详细数据
func QueryProjectPublished(id int32) []*model.Published {
	// 获取项目关联的发布地图
	dppl, p := dbquery.ProjectPublishLink, dbquery.Published
	var publisheds []*model.Published
	err := dppl.Select(p.ID, p.Code, p.Category, p.Type).
		LeftJoin(p, p.ID.EqCol(dppl.Mid)).
		Where(dppl.Pid.Eq(id), p.Status.Eq(1)).Debug().Order(p.Type, p.Code).Scan(&publisheds)
	if err != nil {
		panic(sys_error.New("发布草稿数据失败", err))
	}
	return publisheds
}

// 根据名称获取地图详细信息
func GetPublishedGiByName(param *dto.PublishedSingleQueryDto) *dto.PublishedDto {
	p, pv := dbquery.Published, dbquery.PublishedVersion
	where := p.Select(p.ID, p.Code.As("name"), p.Type, p.Category, pv.Proto).
		LeftJoin(pv, p.DataID.EqCol(pv.ID)).
		Where(p.Code.Eq(param.Name), p.Status.Eq(1))
	var record dto.PublishedDto
	err := where.Debug().Scan(&record)
	if err != nil {
		panic(sys_error.New("查询发布地图信息失败", err))
	}
	return &record
}

// 修改发布数据状态
func ChangePublishStatus(id int32, release bool) {
	var status int
	if release {
		status = 1
	}
	dbquery.Published.Debug().Where(dbquery.Published.ID.Eq(id)).UpdateColumn(dbquery.Published.Status, status)
	if !release { // 下架时，删除关联关系
		dbquery.ProjectPublishLink.Where(dbquery.ProjectPublishLink.Mid.In(id)).Delete()
	}
}

// 修改发布Code
func ChangePublishCode(id int32, code string) {
	p := dbquery.Published
	count, err := p.Where(p.ID.Neq(id), p.Code.Eq(code)).Count()
	if err != nil {
		panic(sys_error.New("修改发布名称失败", err))
	}
	if count > 0 {
		panic(sys_error.New("修改名称失败：名称已存在"))
	}
	p.Debug().Where(dbquery.Published.ID.Eq(id)).UpdateColumn(dbquery.Published.Code, code)
}

// 查询发布历史
func GetPublishHistory(id int32) []*dto.PublishHistoryDto {
	u, p, pv := dbquery.User, dbquery.Published, dbquery.PublishedVersion
	pd, err1 := p.Select(p.ID, p.DataID).Where(p.ID.Eq(id)).First()
	if err1 != nil {
		panic(sys_error.New(fmt.Sprintf("地图【%d】不存在", id)))
	}
	var records []*dto.PublishHistoryDto
	err := pv.
		Select(pv.ID, pv.PublishAt, pv.Note, pv.Version, u.Name.As("publisher"), pv.ID.Eq(pd.DataID).As("current")).
		LeftJoin(u, u.ID.EqCol(pv.UserID)).
		Where(pv.PublishID.Eq(id)).Order(pv.Version.Desc()).Scan(&records)
	if err != nil {
		panic(sys_error.New("查询发布历史信息失败", err))
	}
	return records
}

// 回退发布版本
func FallBackPublishHistory(mapId, versionId int32) (bool, error) {
	p, pv := dbquery.Published, dbquery.PublishedVersion
	pd, err := p.Select(p.ID, p.DataID).Where(p.ID.Eq(mapId)).First()
	if err != nil {
		return false, fmt.Errorf("地图【%d】不存在", mapId)
	}
	pvd, err := pv.Select(pv.ID, pv.PublishID).Where(pv.ID.Eq(versionId)).First()
	if err != nil {
		return false, fmt.Errorf("地图【%d】版本【%d】数据不存在", mapId, versionId)
	}
	if pvd.PublishID != pd.ID {
		return false, fmt.Errorf("地图【%d】版本【%d】数据不匹配", mapId, versionId)
	}
	if pd.DataID == pvd.ID {
		return false, nil
	}
	// 更新版本数据
	p.Where(p.ID.Eq(mapId)).UpdateColumn(p.DataID, versionId)
	return true, nil
}