package model

import (
	"ArmedPolice/app/common/model"
	"ArmedPolice/serve/orm"
	"fmt"
	"gorm.io/gorm"
)

type WorkSchedule struct {
	*model.WorkSchedule
}

type WorkSchedules struct {
	*model.WorkSchedule
	TargetValueTitle string `json:"target_value_title"`
}

// WorkScheduleInfo 工单流程信息
type WorkScheduleInfo struct {
	ID       uint64   `json:"id"`
	Reviewer []string `json:"reviewer"`
}

// ValidateAuth 验证权限
func (m *WorkSchedule) ValidateAuth(uid uint64) (bool, error) {
	// 流程权限信息
	auths := make(map[string]bool, 0)

	for _, v := range m.GetTargetValueAttribute() {
		auths[v] = true
	}
	// 触发审核对象
	switch m.Target {
	case model.WorkScheduleTargetForPerson: // 个人
		_, has := auths[fmt.Sprintf("%d", uid)]
		return has, nil
	case model.WorkScheduleTargetForRole: // 角色
		// 查询角色信息
		roleIDs := make([]uint64, 0)
		mSysUserRole := model.NewSysUserRole()

		if err := model.Pluck(mSysUserRole, "role_id", &roleIDs, model.NewWhere("uid", uid)); err != nil {
			return false, err
		}
		for _, v := range roleIDs {
			if _, has := auths[fmt.Sprintf("%d", v)]; has {
				return has, nil
			}
		}
		break
	}
	return false, nil
}

// FirstSchedule 第一个流程
func (m *WorkSchedule) FirstSchedule(kind model.WorkScheduleKind) (bool, error) {
	db := orm.GetDB().Table(m.TableName()).Select("id", "kind", "title", "stage", "step").
		Where("kind = ?", kind).
		Where("is_deleted = ?", model.DeleteStatusForNot).
		Order("stage " + model.OrderModeToAsc).Order("step " + model.OrderModeToAsc)

	if err := db.First(m.WorkSchedule).Error; err != nil {
		if err == gorm.ErrRecordNotFound {
			return false, nil
		}
		return false, err
	}
	return true, nil
}

// LastSchedule 上一流程信息
func (m *WorkSchedule) LastSchedule() (*WorkScheduleInfo, error) {
	mLastWorkSchedule := model.NewWorkSchedule()

	isExist, err := model.FirstField(mLastWorkSchedule, []string{"id", "stage", "step"},
		model.NewWhere("kind", m.Kind),
		model.NewWhere("stage", m.Stage), model.NewWhereCondition("step", "<", m.Step))

	if err != nil {
		return nil, err
	} else if !isExist { // 直接抛出当前阶段下一流程信息
		return nil, nil
	}
	return &WorkScheduleInfo{ID: mLastWorkSchedule.ID, Reviewer: mLastWorkSchedule.GetTargetValueAttribute()}, err
}

// NextSchedule 下一流程
func (m *WorkSchedule) NextSchedule(isAssets bool) (*WorkScheduleInfo, error) {
	nextWorkSchedule := model.NewWorkSchedule()

	isExist, err := model.FirstWhere(nextWorkSchedule, model.NewWhere("kind", m.Kind),
		model.NewWhere("stage", m.Stage), model.NewWhereCondition("step", ">", m.Step))

	if err != nil {
		return nil, err
	} else if isExist { // 直接抛出当前阶段下一流程信息
		goto RETURN
	}
	// 进入下一阶段
	// 是否需要下一阶段协助
	// 不需要，直接抛出结束
	if !isAssets {
		return nil, nil
	}
	// 下一阶段第一流程信息
	if err = orm.GetDB().Table(nextWorkSchedule.TableName()).
		Where("kind = ? AND is_deleted = ?", m.Kind, model.DeleteStatusForNot).
		Where("stage > ?", m.Stage).
		Order("stage " + model.OrderModeToAsc).Order("step " + model.OrderModeToAsc).
		First(nextWorkSchedule).Error; err != nil {
		if err == gorm.ErrRecordNotFound {
			return nil, nil
		}
		return nil, err
	}
RETURN:
	//var count int64
	//// 判断是否当前阶段第一个元素
	//if err = orm.GetDB().Table(nextWorkSchedule.TableName()).
	//	Where("kind = ? AND is_deleted = ?", nextWorkSchedule.Kind, model.DeleteStatusForNot).
	//	Where("stage = ?", nextWorkSchedule.Stage).
	//	Where("step < ?", nextWorkSchedule.Step).
	//	Count(&count).Error; err != nil {
	//	return nil, err
	//}
	return &WorkScheduleInfo{ID: nextWorkSchedule.ID, Reviewer: nextWorkSchedule.GetTargetValueAttribute()}, err
}

// Schedules 流程信息
func (m *WorkSchedule) Schedules() ([]*WorkSchedules, error) {
	sql := `SELECT s.id, s.kind, s.title, s.stage, s.step, s.target, s.target_value,
CASE s.target 
WHEN %d THEN 
(SELECT GROUP_CONCAT(u_d.name) FROM ( SELECT u.uuid, u.name FROM %s AS u WHERE u.is_deleted = %d) AS u_d WHERE FIND_IN_SET( u_d.uuid, s.target_value ))
WHEN %d THEN 
(SELECT GROUP_CONCAT(r_d.name) FROM (SELECT r.id, r.name FROM %s AS r WHERE r.is_deleted = %d) AS r_d WHERE FIND_IN_SET( r_d.id, s.target_value ))
ELSE "" END AS target_value_title, s.is_countersign, s.created_at
FROM %s AS s WHERE s.is_deleted = %d  ORDER BY s.kind ASC, s.stage ASC, s.step ASC`
	out := make([]*WorkSchedules, 0)

	err := orm.GetDB().Raw(fmt.Sprintf(sql, model.WorkScheduleTargetForPerson, model.NewSysUser().TableName(), model.DeleteStatusForNot,
		model.WorkScheduleTargetForRole, model.NewSysRole().TableName(), model.DeleteStatusForNot,
		m.TableName(), model.DeleteStatusForNot)).Scan(&out).Error

	return out, err
}

// WorkSchedules 工作流程信息
func (m *WorkSchedule) WorkSchedules(kind model.WorkScheduleKind, condition *WorkbenchCondition) ([]uint64, error) {
	sql := `SELECT id FROM %s WHERE 
(CASE target 
WHEN %d THEN 
( SELECT GROUP_CONCAT( a.id SEPARATOR ',' ) FROM ( SELECT id FROM work_schedule WHERE target = 1 AND target_value IN (%s)) AS a ) 
WHEN %d THEN 
(SELECT GROUP_CONCAT( a.id SEPARATOR ',' ) FROM ( SELECT id FROM work_schedule WHERE target = 2 AND target_value IN (%s)) AS a ) 
ELSE "" END) != '' AND kind = %d
AND is_deleted = %d`

	out := make([]uint64, 0)

	err := orm.GetDB().Raw(fmt.Sprintf(sql, m.TableName(),
		model.WorkScheduleTargetForPerson, condition.UID,
		model.WorkScheduleTargetForRole, condition.roleInfo(),
		kind, model.DeleteStatusForNot)).Pluck("id", &out).Error

	return out, err
}

func NewWorkSchedule() *WorkSchedule {
	return &WorkSchedule{model.NewWorkSchedule()}
}