package repair

import (
	"context"
	"database/sql"
	"fmt"
	"lims_adapter/common"
	dao "lims_adapter/dao/repair"
	"lims_adapter/model/repair"
	"strconv"

	"dashoo.cn/common_definition/admin/permission_def"
	"dashoo.cn/micro_libary/micro_srv"
	"dashoo.cn/micro_libary/myerrors"
	"dashoo.cn/micro_libary/request"
	"github.com/gogf/gf/os/gtime"
	"github.com/gogf/gf/util/gvalid"
	"github.com/xuri/excelize/v2"
)

const PermissionRepairProcess = "repair:process"

type RepairService struct {
	Dao       *dao.RepairDao
	DaoFlow   *dao.RepairFlowDao
	DaoResult *dao.RepairResultDao
	Tenant    string
	userInfo  request.UserInfo
}

func NewRepairService(ctx context.Context) (*RepairService, error) {
	tenant, err := micro_srv.GetTenant(ctx)
	if err != nil {
		return nil, fmt.Errorf("获取组合码异常：%s", err.Error())
	}
	// 获取用户信息
	userInfo, err := micro_srv.GetUserInfo(ctx)
	if err != nil {
		return nil, fmt.Errorf("获取用户信息异常：%s", err.Error())
	}
	return &RepairService{
		Dao:       dao.NewRepairDao(tenant),
		DaoFlow:   dao.NewRepairFlowDao(tenant),
		DaoResult: dao.NewRepairResultDao(tenant),
		Tenant:    tenant,
		userInfo:  userInfo,
	}, nil
}

func (s RepairService) Get(ctx context.Context, req *repair.RepairGetReq) (*repair.RepairGetRsp, error) {
	f, err := s.Dao.Where("Id = ?", req.Id).One()
	if err != nil {
		return nil, err
	}
	if f == nil {
		return nil, myerrors.NewMsgError(nil, "报修不存在")
	}
	flow, err := s.DaoFlow.Where("RepairId = ?", f.Id).All()
	if err != nil {
		return nil, err
	}
	result, err := s.DaoResult.Where("RepairId = ?", f.Id).All()
	if err != nil {
		return nil, err
	}

	return &repair.RepairGetRsp{
		Repair: *f,
		Flow:   flow,
		Result: result,
	}, nil
}

func (s RepairService) List(ctx context.Context, req *repair.RepairListReq) (int, []*repair.Repair, error) {
	dao := &s.Dao.RepairDao
	if req.Status != 0 {
		dao = dao.Where("Status = ?", req.Status)
	}
	if req.Type != "" {
		dao = dao.Where("Type = ?", req.Type)
	}
	if req.CreatedByName != "" {
		dao = dao.Where("CreatedByName LIKE ?", fmt.Sprintf("%%%s%%", req.CreatedByName))
	}
	if req.CreatedAtStart != nil {
		dao = dao.Where("CreatedAt > ?", req.CreatedAtStart)
	}
	if req.CreatedAtEnd != nil {
		dao = dao.Where("CreatedAt < ?", req.CreatedAtEnd)
	}

	allow, err := Allow(s.Tenant, s.userInfo.Uuid, PermissionRepairProcess)
	if err != nil {
		return 0, nil, err
	}
	if !allow {
		dao = dao.Where("CreatedById = ?", s.userInfo.Id)
	}

	total, err := dao.Count()
	if err != nil {
		return 0, nil, err
	}

	if req.Page != nil {
		if req.Page.Current == 0 {
			req.Page.Current = 1
		}
		if req.Page.Size == 0 {
			req.Page.Size = 10
		}
		dao = dao.Page(req.Page.Current, req.Page.Size)
	}

	dao = dao.Order("CreatedAt", "desc")
	ent, err := dao.All()
	return total, ent, err
}

type organize struct {
	Id       int
	FullName string
}

func (s RepairService) Add(ctx context.Context, req *repair.RepairAddReq) (int, error) {
	validErr := gvalid.CheckStruct(ctx, req, nil)
	if validErr != nil {
		return 0, myerrors.NewMsgError(nil, validErr.Current().Error())
	}
	dept := &organize{}
	err := s.Dao.DB.Table("base_organize").Where("Id", s.userInfo.DeptId).Struct(dept)
	if err == sql.ErrNoRows {
		return 0, myerrors.NewMsgError(err, fmt.Sprintf("部门不存在 %s", s.userInfo.DeptId))
	}
	if err != nil {
		return 0, err
	}

	id, err := s.Dao.InsertAndGetId(repair.Repair{
		Type:               req.Type,
		Status:             1,
		Content:            req.Content,
		CurrentProcessorId: 0,
		CreatedById:        int(s.userInfo.Id),
		CreatedByName:      s.userInfo.RealName,
		CreatedByMobile:    req.Mobile,
		CreatedByEmail:     req.Email,
		CreatedByDeptId:    dept.Id,
		CreatedByDeptName:  dept.FullName,
		CreatedAt:          gtime.New(),
		UpdatedAt:          gtime.New(),
	})
	if err != nil {
		return 0, err
	}

	_, err = s.DaoFlow.Insert(repair.RepairFlow{
		RepairId:      int(id),
		Type:          1,
		Status:        1,
		ProcessById:   int(s.userInfo.Id),
		ProcessByName: s.userInfo.RealName,
		Note:          "",
		CreatedAt:     gtime.New(),
		UpdatedAt:     gtime.New(),
	})
	return int(id), err
}

type user struct {
	Id       int
	Realname string
}

func (s RepairService) Trans(ctx context.Context, req *repair.RepairTransReq) error {
	validErr := gvalid.CheckStruct(ctx, req, nil)
	if validErr != nil {
		return myerrors.NewMsgError(nil, validErr.Current().Error())
	}
	trnasTo := user{}
	err := s.Dao.DB.Table("base_user").Where("Id", req.UserId).Struct(&trnasTo)
	if err == sql.ErrNoRows {
		return myerrors.NewMsgError(nil, fmt.Sprintf("转交人不存在: %d", req.UserId))
	}
	if err != nil {
		return err
	}

	f, err := s.Dao.Where("Id = ?", req.Id).One()
	if err != nil {
		return err
	}
	if f == nil {
		return myerrors.NewMsgError(nil, fmt.Sprintf("报修不存在: %d", req.Id))
	}

	_, err = s.Dao.Where("Id = ?", req.Id).Data(
		map[string]interface{}{
			"CurrentProcessorId":   req.UserId,
			"CurrentProcessorName": trnasTo.Realname,
		}).Update()
	if err != nil {
		return err
	}
	_, err = s.DaoFlow.Insert(repair.RepairFlow{
		RepairId:      req.Id,
		Type:          2,
		Status:        1,
		ProcessById:   int(s.userInfo.Id),
		ProcessByName: s.userInfo.RealName,
		Note:          req.Note,
		CreatedAt:     gtime.New(),
		UpdatedAt:     gtime.New(),
	})
	return err
}

func (s RepairService) Process(ctx context.Context, req *repair.RepairProcessReq) error {
	validErr := gvalid.CheckStruct(ctx, req, nil)
	if validErr != nil {
		return myerrors.NewMsgError(nil, validErr.Current().Error())
	}
	f, err := s.Dao.Where("Id = ?", req.Id).One()
	if err != nil {
		return err
	}
	if f == nil {
		return myerrors.NewMsgError(nil, fmt.Sprintf("报修不存在: %d", req.Id))
	}

	_, err = s.Dao.Where("Id = ?", req.Id).Data(
		map[string]interface{}{
			"CurrentProcessorId":   s.userInfo.Id,
			"CurrentProcessorName": s.userInfo.RealName,
			"ProcessedAt":          gtime.Now(),
			"ProcessType":          req.Type,
			"Status":               2,
		}).Update()
	if err != nil {
		return err
	}
	_, err = s.DaoFlow.Insert(repair.RepairFlow{
		RepairId:      req.Id,
		Type:          3,
		Status:        1,
		ProcessById:   int(s.userInfo.Id),
		ProcessByName: s.userInfo.RealName,
		ProcessType:   req.Type,
		Note:          req.Note,
		CreatedAt:     gtime.New(),
		UpdatedAt:     gtime.New(),
	})
	if err != nil {
		return err
	}
	_, err = s.DaoResult.Insert(repair.RepairResult{
		RepairId:      req.Id,
		ProcessById:   int(s.userInfo.Id),
		ProcessByName: s.userInfo.RealName,
		ProcessType:   req.Type,
		ProcessNote:   req.Note,
		CreatedAt:     gtime.New(),
		UpdatedAt:     gtime.New(),
	})
	return err
}

func (s RepairService) Reactivate(ctx context.Context, req *repair.RepairReactivateReq) error {
	validErr := gvalid.CheckStruct(ctx, req, nil)
	if validErr != nil {
		return myerrors.NewMsgError(nil, validErr.Current().Error())
	}
	f, err := s.Dao.Where("Id = ?", req.Id).One()
	if err != nil {
		return err
	}
	if f == nil {
		return myerrors.NewMsgError(nil, fmt.Sprintf("报修不存在: %d", req.Id))
	}

	_, err = s.Dao.Where("Id = ?", req.Id).Data(
		map[string]interface{}{
			"Status":               1,
			"CurrentProcessorId":   0,
			"CurrentProcessorName": nil,
			"ProcessedAt":          nil,
			"ProcessType":          nil,
		}).Update()
	if err != nil {
		return err
	}
	_, err = s.DaoFlow.Insert(repair.RepairFlow{
		RepairId:      req.Id,
		Type:          4,
		Status:        1,
		ProcessById:   int(s.userInfo.Id),
		ProcessByName: s.userInfo.RealName,
		Note:          req.Note,
		CreatedAt:     gtime.New(),
		UpdatedAt:     gtime.New(),
	})
	return err
}

type id struct {
	Id int
}

func (s RepairService) Processor(ctx context.Context) ([]repair.RepairProcessorRsp, error) {
	rsp := []repair.RepairProcessorRsp{}
	menu := &id{}
	err := s.Dao.DB.Table("base_menu").
		Where("Permission = ?", PermissionRepairProcess).
		Fields("Id").Struct(menu)
	if err == sql.ErrNoRows {
		return nil, myerrors.NewMsgError(err,
			fmt.Sprintf("未配置权限: %s", PermissionRepairProcess))
	}
	if err != nil {
		return nil, err
	}

	roles := []id{}
	err = s.Dao.DB.Table("base_role_menu").
		Where("find_in_set(?, `MenuIds`)", menu.Id).
		Fields("RoleId as Id").Structs(&roles)
	if err == sql.ErrNoRows {
		return rsp, nil
	}
	if err != nil {
		return nil, err
	}
	if len(roles) == 0 {
		return rsp, nil
	}

	dao := s.Dao.DB.Table("base_user a").LeftJoin("base_user_role b", "b.UserId=a.Id")
	orsql := ""
	for i, r := range roles {
		if i != 0 {
			orsql += " OR "
		}
		orsql += fmt.Sprintf("find_in_set(%d, `RoleIds`)", r.Id)
	}
	dao = dao.Where("a.Enabled = 1").Where(fmt.Sprintf("(%s)", orsql))
	err = dao.Fields("a.Id, a.Realname").Structs(&rsp)
	if err == sql.ErrNoRows {
		return rsp, nil
	}
	return rsp, err
}

func (s RepairService) Delete(ctx context.Context, id []int) error {
	_, err := s.Dao.Where("Id IN (?)", id).Delete()
	if err != nil {
		return err
	}
	_, err = s.DaoFlow.Where("RepairId IN (?)", id).Delete()
	if err != nil {
		return err
	}
	_, err = s.DaoResult.Where("RepairId IN (?)", id).Delete()
	return err
}

func (s RepairService) Export(ctx context.Context, req *repair.RepairListReq) (*excelize.File, error) {
	_, data, err := s.List(ctx, req)
	if err != nil {
		return nil, err
	}

	typeMap, err := common.DictAsMap(s.Tenant, "RepairType")
	if err != nil {
		return nil, myerrors.NewMsgError(nil, fmt.Sprintf("获取字典数据错误 RepairType %s", err.Error()))
	}

	processTypeMap, err := common.DictAsMap(s.Tenant, "TreatmentMethod")
	if err != nil {
		return nil, myerrors.NewMsgError(nil, fmt.Sprintf("获取字典数据错误 TreatmentMethod %s", err.Error()))
	}

	statusMap := map[int]string{
		1: "未处理",
		2: "已处理",
	}

	f := excelize.NewFile()
	sheet := "Sheet1"
	header := []string{
		"报修人姓名", "报修类型", "报修时间", "故障描述", "处理状态", "处理人", "处理方式", "处理时间",
	}
	colWidth := []float64{
		12, 12, 20, 40, 12, 12, 12, 20,
	}

	colStyle, err := f.NewStyle(&excelize.Style{
		Alignment: &excelize.Alignment{
			Horizontal: "center",
			Vertical:   "center",
			WrapText:   true,
		},
		Font: &excelize.Font{
			Size:   11,
			Family: "宋体",
		},
	})
	if err != nil {
		return nil, err
	}
	headerStyle, err := f.NewStyle(&excelize.Style{
		Alignment: &excelize.Alignment{
			Horizontal: "center",
		},
		Fill: excelize.Fill{
			Type:    "pattern",
			Color:   []string{"#a6a6a6"},
			Pattern: 1,
		},
		Border: []excelize.Border{
			{Type: "left", Color: "#000000", Style: 1},
			{Type: "top", Color: "#000000", Style: 1},
			{Type: "bottom", Color: "#000000", Style: 1},
			{Type: "right", Color: "#000000", Style: 1},
		},
	})
	if err != nil {
		return nil, err
	}

	lastcol, err := excelize.ColumnNumberToName(len(header))
	if err != nil {
		return nil, err
	}
	err = f.SetColStyle(sheet, "A:"+lastcol, colStyle)
	if err != nil {
		return nil, err
	}
	err = f.SetCellStyle(sheet, "A1", lastcol+"1", headerStyle)
	if err != nil {
		return nil, err
	}
	for i := range header {
		n, err := excelize.ColumnNumberToName(i + 1)
		if err != nil {
			return nil, err
		}
		f.SetCellValue(sheet, n+"1", header[i])
	}

	for i, w := range colWidth {
		n, err := excelize.ColumnNumberToName(i + 1)
		if err != nil {
			return nil, err
		}
		err = f.SetColWidth(sheet, n, n, w)
		if err != nil {
			return nil, err
		}
	}

	for row, item := range data {
		rowName := strconv.Itoa(row + 2)
		f.SetCellValue(sheet, "A"+rowName, item.CreatedByName)
		f.SetCellValue(sheet, "B"+rowName, typeMap[item.Type])
		f.SetCellValue(sheet, "C"+rowName, item.CreatedAt)
		f.SetCellValue(sheet, "D"+rowName, item.Content)
		f.SetCellValue(sheet, "E"+rowName, statusMap[item.Status])
		f.SetCellValue(sheet, "F"+rowName, item.CurrentProcessorName)
		f.SetCellValue(sheet, "G"+rowName, processTypeMap[item.ProcessType])
		f.SetCellValue(sheet, "H"+rowName, item.ProcessedAt)
	}

	index := f.NewSheet(sheet)
	f.SetActiveSheet(index)
	return f, nil
}

func Allow(tenant, uuid, permission string) (bool, error) {
	permissionSrv := micro_srv.InitMicroSrvClient("Permission", "micro_srv.admin")
	defer permissionSrv.Close()
	rsp := &permission_def.PermissionResp{}
	err := permissionSrv.Call(context.TODO(), "GetAllPermissionByUser", &permission_def.UuidReq{
		Tenant: tenant,
		Uuid:   uuid,
	}, rsp)
	if err != nil {
		return false, fmt.Errorf("获取权限失败 %s", err.Error())
	}
	for _, p := range rsp.UserPermissions {
		if p == permission {
			return true, nil
		}
	}
	return false, nil
}