package service

import (
	"context"
	"dashoo.cn/micro/app/dao"
	"dashoo.cn/micro/app/model"
	"dashoo.cn/opms_libary/myerrors"
	"database/sql"
	"github.com/gogf/gf/frame/g"
	"github.com/gogf/gf/text/gstr"
	"github.com/gogf/gf/util/gconv"
)

type DictDataService struct {
	*contextService
	Dao *dao.SysDictDataDao
}

func NewDictDataService(ctx context.Context) (svc *DictDataService, err error) {
	svc = new(DictDataService)
	if svc.contextService, err = svc.Init(ctx); err != nil {
		return nil, err
	}
	svc.Dao = dao.NewSysDictDataDao(svc.Tenant)
	return svc, nil
}

func (s *DictDataService) GetDictDataList(req *model.SelectDictPageReq) (total int, list []*model.SysDictData, err error) {
	db := s.Dao.Ctx(req.Ctx)
	if req != nil {
		if req.DictLabel != "" {
			db = db.Where(s.Dao.C.DictLabel+" like ?", "%"+req.DictLabel+"%")
		}
		if req.Status != "" {
			db = db.Where(s.Dao.C.Status+" = ", gconv.Int(req.Status))
		}
		if req.DictType != "" {
			db = db.Where(s.Dao.C.DictType+" = ?", req.DictType)
		}
		total, err = db.Count()
		if err != nil {
			g.Log().Error(err)
			err = myerrors.TipsError("获取总行数失败")
			return
		}
	}
	list, err = db.Page(req.GetPage()).Order(s.Dao.C.DictSort + " asc," + s.Dao.C.DictCode + " asc").All()
	if err != nil {
		g.Log().Error(err)
		err = myerrors.TipsError("获取数据失败")
		return
	}
	return
}

// GetDictDataById 通过字典数据id获取字典数据
func (s *DictDataService) GetDictDataById(id int64) (data *model.SysDictData, err error) {
	data, err = s.Dao.FindOne(s.Dao.C.DictCode, id)
	if err != nil {
		g.Log().Error(err)
		err = myerrors.TipsError("获取字典数据失败")
		return
	}
	if data == nil {
		err = myerrors.TipsError("获取字典数据失败")
	}
	return
}

// GetDictWithDataByType 通过字典键类型获取选项
func (s *DictDataService) GetDictWithDataByType(req *model.GetDictReq) (dict *model.DictRes, err error) {
	//从数据库获取
	dict = &model.DictRes{}
	//获取类型数据
	err = s.Dao.DB.Model("sys_dict_type").Where(dao.SysDictType.C.DictType, req.DictType).
		Where(dao.SysDictType.C.Status, "10").Fields(model.DictTypeRes{}).Scan(&dict.Info)
	if err != nil {
		g.Log().Error(err)
		err = myerrors.TipsError("获取字典类型失败")
	}
	err = s.Dao.Where(s.Dao.C.DictType, req.DictType).Where(s.Dao.C.Status, "10").
		Order(s.Dao.C.DictSort + " asc," + s.Dao.C.DictCode + " asc").
		Scan(&dict.Values)
	if err != nil {
		g.Log().Error(err)
		err = myerrors.TipsError("获取字典数据失败")
	}

	//设置给定的默认值
	for _, v := range dict.Values {
		if req.DefaultValue != "" {
			if gstr.Equal(req.DefaultValue, v.DictValue) {
				v.IsDefault = 1
			} else {
				v.IsDefault = 0
			}
		}
	}
	return
}

// CheckDictTypeUniqueAll 检查字典类型是否唯一
func (s *DictDataService) CheckDictTypeUniqueAll(dictType string) bool {
	dict, err := s.Dao.FindOne(s.Dao.C.DictType+"=?", dictType)
	if err != nil {
		g.Log().Error(err)
		return false
	}
	if dict != nil {
		return false
	}
	return true
}

// Create 添加保存字典数据
func (s *DictDataService) Create(req *model.DictDataAddReq) (id int64, err error) {
	var res sql.Result
	data := new(model.SysDictData)
	if err := gconv.Struct(req, data); err != nil {
		return -1, err
	}
	SetCreatedInfo(data, s.GetCxtUserId(), s.GetCxtUserName())
	res, err = s.Dao.Data(data).Insert()
	if err != nil {
		g.Log().Error(err)
		err = myerrors.TipsError("添加字典数据失败")
		return
	}
	id, err = res.LastInsertId()
	return
}

// UpdateByDict 修改字典数据
func (s *DictDataService) UpdateByDict(req *model.EditDictDataReq) (err error) {
	data := new(model.SysDictData)
	if err := gconv.Struct(req, data); err != nil {
		return err
	}
	SetUpdatedInfo(data, s.GetCxtUserId(), s.GetCxtUserName())
	updateFieldEx := append(CommonUpdateFieldEx, dao.SysDictData.C.DictCode)
	_, err = s.Dao.FieldsEx(updateFieldEx...).WherePri(req.DictCode).Update(data)
	return
}

// DeleteDictDataByIds 删除字典数据
func (s *DictDataService) DeleteDictDataByIds(ids []int64) error {
	_, err := s.Dao.Where(s.Dao.C.DictCode+" in(?)", ids).Delete()
	if err != nil {
		g.Log().Error(err)
		return myerrors.TipsError("删除失败")
	}
	return nil
}

// GetDictLabelByTypeAndValue 根据字典类型和字典值获取字典明细名称
func (s *DictDataService) GetDictLabelByTypeAndValue(req *model.GetDictLabelByTypeAndValueReq) (string, error) {
	result, err := s.Dao.Where(s.Dao.C.DictType, req.DictType).Where(s.Dao.C.DictValue, req.DictValue).Fields(s.Dao.C.DictLabel).Value()
	if err != nil {
		g.Log().Error(err)
		return req.DictValue, myerrors.TipsError("查询失败")
	}
	return result.String(), nil
}