package repository

import (
	"errors"
	"fmt"
	"time"

	"github.com/go-pg/pg/v10"
	pgTransaction "github.com/linmadan/egglib-go/transaction/pg"
	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/domain"
	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/infrastructure/pg/models"
)

type StaffAssessRepository struct {
	transactionContext *pgTransaction.TransactionContext
}

var _ domain.StaffAssessRepository = (*StaffAssessRepository)(nil)

func NewStaffAssessRepository(transactionContext *pgTransaction.TransactionContext) *StaffAssessRepository {
	return &StaffAssessRepository{transactionContext: transactionContext}
}

func (repo *StaffAssessRepository) TransformToDomain(d *models.StaffAssess) *domain.StaffAssess {
	return &domain.StaffAssess{
		Id:                    d.Id,
		CompanyId:             d.CompanyId,
		EvaluationProjectId:   d.EvaluationProjectId,
		EvaluationProjectName: d.EvaluationProjectName,
		CycleId:               d.CycleId,
		CycleName:             d.CycleName,
		StaffAssessTaskId:     d.StaffAssessTaskId,
		TargetUser:            d.TargetUser,
		TargetDepartment:      d.TargetDepartment,
		Executor:              d.Executor,
		Types:                 domain.StaffAssessType(d.Types),
		LinkNodeId:            d.LinkNodeId,
		LinkNodeName:          d.LinkNodeName,
		Status:                domain.StaffAssessStatus(d.Status),
		BeginTime:             d.BeginTime,
		EndTime:               d.EndTime,
		CreatedAt:             d.CreatedAt,
		UpdatedAt:             d.UpdatedAt,
		DeletedAt:             d.DeletedAt,
	}
}

func (repo *StaffAssessRepository) Save(d *domain.StaffAssess) (*domain.StaffAssess, error) {
	saveModel := models.StaffAssess{
		Id:                    d.Id,
		CompanyId:             d.CompanyId,
		EvaluationProjectId:   d.EvaluationProjectId,
		EvaluationProjectName: d.EvaluationProjectName,
		CycleId:               d.CycleId,
		CycleName:             d.CycleName,
		StaffAssessTaskId:     d.StaffAssessTaskId,
		TargetUser:            d.TargetUser,
		TargetDepartment:      d.TargetDepartment,
		Executor:              d.Executor,
		Types:                 string(d.Types),
		LinkNodeId:            d.LinkNodeId,
		LinkNodeName:          d.LinkNodeName,
		Status:                string(d.Status),
		BeginTime:             d.BeginTime,
		EndTime:               d.EndTime,
		CreatedAt:             d.CreatedAt,
		UpdatedAt:             d.UpdatedAt,
		DeletedAt:             d.DeletedAt,
	}
	tx := repo.transactionContext.PgTx
	var err error
	if saveModel.Id == 0 {
		_, err = tx.Model(&saveModel).Insert()
		if err != nil {
			return nil, err
		}
	} else {
		_, err = tx.Model(&saveModel).WherePK().Update()
		if err != nil {
			return nil, err
		}
	}
	d.Id = saveModel.Id
	return d, nil
}

func (repo *StaffAssessRepository) Remove(id int) error {
	tx := repo.transactionContext.PgTx
	nowTime := time.Now()
	_, err := tx.Model(&models.StaffAssess{}).
		Where("id=?", id).
		Set("deleted_at=?", nowTime).
		Update()
	return err
}

func (repo *StaffAssessRepository) FindOne(queryOptions map[string]interface{}) (*domain.StaffAssess, error) {
	tx := repo.transactionContext.PgTx
	m := new(models.StaffAssess)
	query := tx.Model(m)
	query.Where("deleted_at isnull")
	if id, ok := queryOptions["id"]; ok {
		query.Where("id=?", id)
	}
	if err := query.First(); err != nil {
		if errors.Is(err, pg.ErrNoRows) {
			return nil, fmt.Errorf("没有此资源")
		} else {
			return nil, err
		}
	}
	u := repo.TransformToDomain(m)
	return u, nil
}

func (repo *StaffAssessRepository) Find(queryOptions map[string]interface{}) (int, []*domain.StaffAssess, error) {
	tx := repo.transactionContext.PgTx
	var m []*models.StaffAssess
	query := tx.Model(&m).
		Where("staff_assess.deleted_at isnull").
		Join(`JOIN staff_assess_task ON staff_assess_task."id" = staff_assess."staff_assess_task_id" and staff_assess_task."deleted_at" isnull`)
	if companyId, ok := queryOptions["companyId"]; ok {
		query.Where("staff_assess.company_id = ?", companyId)
	}
	if v, ok := queryOptions["limit"].(int); ok {
		query.Limit(v)
	}
	if v, ok := queryOptions["offset"].(int); ok {
		query.Offset(v)
	}
	if v, ok := queryOptions["id"]; ok {
		query.Where("staff_assess.id=?", v)
	}
	if v, ok := queryOptions["targetUserId"]; ok {
		query.Where(`staff_assess.target_user->>'userId'='?'`, v)
	}
	if v, ok := queryOptions["targetUserIds"]; ok {
		query.Where(`staff_assess.target_user->>'userId' in(?)`, pg.In(v))
	}
	if v, ok := queryOptions["targetUserName"].(string); ok {
		query.Where(`staff_assess.target_user->>'userName' like ?`, fmt.Sprintf("%%%v%%", v))
	}
	if v, ok := queryOptions["executorId"]; ok {
		query.Where(`staff_assess.executor->>'userId'='?'`, v)
	}
	if v, ok := queryOptions["cycleId"]; ok {
		query.Where(`staff_assess.cycle_id=?`, v)
	}
	if v, ok := queryOptions["staffAssessTaskId"]; ok {
		query.Where(`staff_assess.staff_assess_task_id=?`, v)
	}
	if v, ok := queryOptions["types"]; ok {
		query.Where(`staff_assess.types=?`, v)
	}
	if v, ok := queryOptions["typesList"].([]string); ok {
		query.Where("staff_assess.types in(?)", pg.In(v))
	}
	if v, ok := queryOptions["status"]; ok {
		query.Where("staff_assess.status=?", v)
	}
	if v, ok := queryOptions["endTime"]; ok {
		query.Where("staff_assess.end_time<=?", v)
	}
	if v, ok := queryOptions["beginDay"]; ok {
		query.Where("to_char(staff_assess.begin_time at time zone 'PRC','YYYY-MM-DD')= ? ", v)
	}
	if v, ok := queryOptions["evaluationProjectId"]; ok {
		query.Where("staff_assess.evaluation_project_id=?", v)
	}
	//查询第几号日期的数据
	if v, ok := queryOptions["beginDayNumber"]; ok {
		query.Where("date_part('day',staff_assess.begin_time) = ?", v)
	}

	query.Order("staff_assess.id DESC")
	count, err := query.SelectAndCount()
	if err != nil {
		return 0, nil, err
	}
	arrays := make([]*domain.StaffAssess, 0)
	for _, v := range m {
		d := repo.TransformToDomain(v)
		arrays = append(arrays, d)
	}
	return count, arrays, nil
}