package dao

import (
	"time"

	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/domain"

	"github.com/go-pg/pg/v10"
	pgTransaction "github.com/linmadan/egglib-go/transaction/pg"
)

type SummaryEvaluationDao struct {
	transactionContext *pgTransaction.TransactionContext
}

func NewSummaryEvaluationDao(options map[string]interface{}) *SummaryEvaluationDao {
	var transactionContext *pgTransaction.TransactionContext
	if value, ok := options["transactionContext"]; ok {
		transactionContext = value.(*pgTransaction.TransactionContext)
	}
	return &SummaryEvaluationDao{
		transactionContext: transactionContext,
	}
}

type ExecutorCycle struct {
	CycleId   string    `pg:"cycle_id" `  //周期id
	CycleName string    `pg:"cycle_name"` //周期名称
	CreatedAt time.Time `pg:"created_at"`
}

// GetExecutorCycleList 获取执行人拥有的周期列表
// executorId 执行人id
// offset,limit 分页
func (d *SummaryEvaluationDao) GetExecutorCycleList(companyId int, executorId int, offset int, limit int, isHrbp bool) ([]ExecutorCycle, error) {
	sqlStr := `select  
	distinct on(
		summary_evaluation.cycle_id ,
		summary_evaluation.cycle_name) 
	summary_evaluation.created_at ,
	summary_evaluation.cycle_id ,
	summary_evaluation.cycle_name 
	from summary_evaluation 
	where summary_evaluation.company_id=? 
	and summary_evaluation.begin_time <=now() 
	and summary_evaluation.deleted_at isnull
	`
	tx := d.transactionContext.PgTx
	condition := []interface{}{
		companyId, executorId,
	}
	if isHrbp {
		sqlStr += ` and (summary_evaluation.executor ->>'userId'='?' or summary_evaluation."types"=4 ) `
	} else {
		sqlStr += ` and (summary_evaluation.executor ->>'userId'='?') `
	}
	condition = append(condition, offset, limit)

	sqlStr1 := `with t1 as ( ` + sqlStr + ` ) select * from  t1 order by t1.created_at desc  offset ? limit ? `
	result := []ExecutorCycle{}
	_, err := tx.Query(&result, sqlStr1, condition...)
	return result, err
}

// CountExecutorCycleList 统计执行人拥有的周期列表
func (d *SummaryEvaluationDao) CountExecutorCycleList(companyId int, executorId int, isHrbp bool) (int, error) {
	sqlStr := `select count(
		distinct summary_evaluation.cycle_id
	  ) as cnt
	from  summary_evaluation 
	where  summary_evaluation.company_id=? and summary_evaluation.deleted_at isnull `

	tx := d.transactionContext.PgTx
	condition := []interface{}{
		companyId, executorId,
	}
	if isHrbp {
		sqlStr += ` and (summary_evaluation.executor ->>'userId'='?' or summary_evaluation."types"=4 ) `
	} else {
		sqlStr += ` and (summary_evaluation.executor ->>'userId'='?') `
	}
	var cnt int
	_, err := tx.QueryOne(pg.Scan(&cnt), sqlStr, condition...)
	return cnt, err
}

type TargetUserCycle struct {
	CycleId               string    `pg:"cycle_id" `  //周期id
	CycleName             string    `pg:"cycle_name"` //周期名称
	BeginTime             time.Time `pg:"begin_time"`
	EndTime               time.Time `pg:"end_time"`
	EvaluationProjectId   string    `pg:"evaluation_project_id"`
	EvaluationProjectName string    `pg:"evaluation_project_name"`
	TargetUserId          string    `pg:"target_user_id"`
}

// GetExecutorCycleList 获取被评估目标人拥有的周期列表
// executorId 执行人id
// offset,limit 分页
func (d *SummaryEvaluationDao) GetTargetUserCycleList(targetUserId int, offset int, limit int, evaluationType int) ([]TargetUserCycle, error) {
	sqlStr := `select  
	distinct 
	summary_evaluation.cycle_id ,
	summary_evaluation.begin_time ,
	summary_evaluation.cycle_name ,
	summary_evaluation.evaluation_project_id ,
	summary_evaluation.evaluation_project_name ,
	summary_evaluation.target_user ->>'userId' as target_user_id
	from summary_evaluation 
	where summary_evaluation.deleted_at isnull and summary_evaluation.target_user ->>'userId'='?'
	`
	tx := d.transactionContext.PgTx
	condition := []interface{}{
		targetUserId,
	}

	if evaluationType > 0 {
		sqlStr += `	and summary_evaluation."types"=? `
		condition = append(condition, evaluationType)
	}

	condition = append(condition, offset, limit)
	sqlStr += ` order by summary_evaluation.begin_time desc offset ? limit ? `
	result := []TargetUserCycle{}
	_, err := tx.Query(&result, sqlStr, condition...)
	return result, err
}

// CountExecutorCycleList 统计 被评估目标人拥有的周期列表
func (d *SummaryEvaluationDao) CountTargetUserCycleList(executorId int, evaluationType int) (int, error) {
	sqlStr := `select count(
		distinct summary_evaluation.cycle_id
	  ) as cnt
	from  summary_evaluation 
	where summary_evaluation.target_user ->>'userId'='?' `

	condition := []interface{}{
		executorId,
	}
	if evaluationType > 0 {
		sqlStr += `	and summary_evaluation."types"=? `
		condition = append(condition, evaluationType)
	}
	tx := d.transactionContext.PgTx
	var cnt int
	_, err := tx.QueryOne(pg.Scan(&cnt), sqlStr, condition...)
	return cnt, err
}

// TargetUnconfirmedCycleList 用户【未确认绩效成绩】的周期列表
func (d *SummaryEvaluationDao) TargetUnconfirmedCycleList(companyId int, executorId int) ([]TargetUserCycle, error) {
	sqlStr := `select 
	summary_evaluation.cycle_id, 
	summary_evaluation.begin_time, 
	summary_evaluation.end_time,
	summary_evaluation.cycle_name ,
	summary_evaluation.evaluation_project_id ,
	summary_evaluation.evaluation_project_name ,
	summary_evaluation.target_user ->>'userId' as target_user_id
	from summary_evaluation 
	where summary_evaluation.deleted_at isnull 
          and summary_evaluation.company_id='?' 
          and summary_evaluation.target_user ->>'userId'='?' 
          and summary_evaluation.types='?' 
          and summary_evaluation.status=? 
          and summary_evaluation.check_result=? 
	`
	tx := d.transactionContext.PgTx
	condition := []interface{}{companyId, executorId, domain.EvaluationFinish, domain.EvaluationCompleted, domain.EvaluationCheckUncompleted}
	sqlStr += ` order by summary_evaluation.begin_time desc;`
	result := make([]TargetUserCycle, 0)
	_, err := tx.Query(&result, sqlStr, condition...)
	return result, err
}

func (d *SummaryEvaluationDao) UpdateBeginTime(ids []int, beginTime time.Time) error {
	if len(ids) == 0 {
		return nil
	}
	sqlStr := `update summary_evaluation set begin_time =? 
	where  summary_evaluation.id in(?) `
	condition := []interface{}{
		beginTime, pg.In(ids),
	}
	tx := d.transactionContext.PgTx
	_, err := tx.Exec(sqlStr, condition...)
	return err
}

type SummaryEvaluationData1 struct {
	SummaryEvaluationId int    `pg:"summary_evaluation_id"`
	TargetUserId        string `pg:"target_user_id"`
	CompanyId           int64  `pg:"company_id"`
}

// 查询周期考核结果
// 条件：已过截止时间,并且还没确认周期考核结果
func (d *SummaryEvaluationDao) ListEvaluationFinishNoResult() ([]SummaryEvaluationData1, error) {
	sqlStr := `select 
	summary_evaluation.id  as summary_evaluation_id,
	summary_evaluation.target_user ->>'userId' as target_user_id,
	summary_evaluation.company_id 
	from summary_evaluation
	where 1=1
	and summary_evaluation."types" = 5
	and summary_evaluation.status ='completed'
	and summary_evaluation.check_result ='uncompleted'
	and summary_evaluation.end_time <=now()
	and summary_evaluation.deleted_at isnull 
	`
	result := []SummaryEvaluationData1{}
	tx := d.transactionContext.PgTx
	_, err := tx.Query(&result, sqlStr)
	return result, err
}

type SummaryEvaluationCycle struct {
	CycleId   string `pg:"cycle_id" json:"cycleId"` //周期id
	CompanyId string `pg:"company_id" json:"companyId"`
	CycleName string `pg:"cycle_name" json:"cycleName"` //周期名称
}

// 查询周期列表
func (d *SummaryEvaluationDao) ListCycle(companyId int) ([]SummaryEvaluationCycle, error) {
	sqlStr := ` select 
	distinct  summary_evaluation.cycle_id ,summary_evaluation.cycle_name ,summary_evaluation.company_id
	from summary_evaluation
	where summary_evaluation."types" =5 
	and summary_evaluation.company_id =? 
	order by summary_evaluation.cycle_id desc 
	limit 1000 `
	result := []SummaryEvaluationCycle{}
	tx := d.transactionContext.PgTx
	_, err := tx.Query(&result, sqlStr, companyId)
	return result, err

}