package repository

import (
	"errors"
	"fmt"
	"strconv"
	"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 TaskRepository struct {
	transactionContext *pgTransaction.TransactionContext
}

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

func NewTaskRepository(transactionContext *pgTransaction.TransactionContext) *TaskRepository {
	return &TaskRepository{transactionContext: transactionContext}
}

func (repo *TaskRepository) TransformToDomain(d *models.Task) *domain.Task {
	return &domain.Task{
		Id:            d.Id,
		CreatedAt:     d.CreatedAt,
		UpdatedAt:     d.UpdatedAt,
		DeletedAt:     d.DeletedAt,
		CompanyId:     d.CompanyId,
		Name:          d.Name,
		Alias:         d.Alias,
		Leader:        d.Leader,
		Status:        domain.TaskState(d.Status),
		Level:         d.Level,
		LevelName:     d.LevelName,
		SortBy:        domain.TaskSortBy(d.SortBy),
		EndTime:       d.EndTime,
		UseEndTime:    d.UseEndTime,
		RelatedUser:   d.RelatedUser,
		RunAt:         d.RunAt,
		StopAt:        d.StopAt,
		Anomaly:       d.Anomaly,
		WarnFlag:      domain.TaskWarnFlag(d.WarnFlag),
		AssistFlag:    d.AssistFlag,
		AssistFlagMax: d.AssistFlagMax,
		CurrentStage:  d.CurrentStage,
		LastStage:     d.LastStage,
		CreatedBy:     d.CreatedBy,
	}
}

func (repo *TaskRepository) Save(param *domain.Task) error {
	param.UpdatedAt = time.Now()
	if param.Id == 0 {
		param.CreatedAt = time.Now()
	}
	m := models.Task{
		Id:            param.Id,
		CreatedAt:     param.CreatedAt,
		UpdatedAt:     param.UpdatedAt,
		DeletedAt:     param.DeletedAt,
		Name:          param.Name,
		Alias:         param.Alias,
		CompanyId:     param.CompanyId,
		Leader:        param.Leader,
		Status:        int(param.Status),
		Level:         param.Level,
		LevelName:     param.LevelName,
		RelatedUser:   param.RelatedUser,
		LastStage:     param.LastStage,
		RunAt:         param.RunAt,
		StopAt:        param.StopAt,
		Anomaly:       param.Anomaly,
		WarnFlag:      int(param.WarnFlag),
		CurrentStage:  param.CurrentStage,
		SortBy:        int(param.SortBy),
		EndTime:       param.EndTime,
		UseEndTime:    param.UseEndTime,
		AssistFlag:    param.AssistFlag,
		AssistFlagMax: param.AssistFlagMax,
		CreatedBy:     param.CreatedBy,
	}
	db := repo.transactionContext.PgTx
	if m.Id == 0 {
		_, err := db.Model(&m).Insert()
		if err != nil {
			return err
		}
	} else {
		_, err := db.Model(&m).WherePK().Update()
		if err != nil {
			return err
		}
	}
	param.Id = m.Id
	return nil
}

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

}

func (repo *TaskRepository) FindOne(queryOptions map[string]interface{}) (*domain.Task, error) {
	tx := repo.transactionContext.PgTx
	m := new(models.Task)
	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("没有找到task数据")
		} else {
			return nil, err
		}
	}
	u := repo.TransformToDomain(m)
	return u, nil
}

func (repo *TaskRepository) Find(queryOptions map[string]interface{}) (int, []*domain.Task, error) {
	tx := repo.transactionContext.PgTx
	var m []*models.Task
	query := tx.Model(&m).
		Where("deleted_at isnull").
		Limit(20)
	if val, ok := queryOptions["name"]; ok {
		query.Where("task.name like ?", val)
	}
	if val, ok := queryOptions["companyId"]; ok {
		query.Where("task.company_id = ?", val)
	}
	if val, ok := queryOptions["id"]; ok {
		query.Where("task.id=?", val)
	}
	if val, ok := queryOptions["ids"]; ok {
		query.Where("task.id in(?)", pg.In(val))
	}
	if val, ok := queryOptions["leaderId"]; ok {
		query.Where("task.leader->>'id'=?", val)
	}
	if val, ok := queryOptions["aliasOrLeader"]; ok {
		query.Where(`task.alias like ? or task.leader->>'name' like ?`, val, val)
	}
	if val, ok := queryOptions["status"]; ok {
		query.Where("task.status=?", val)
	}
	if val, ok := queryOptions["createdBy"]; ok {
		query.Where("created_by = ?", val)
	}
	if val, ok := queryOptions["levelName"]; ok {
		query.Where("level_name like ?", val)
	}
	if val, ok := queryOptions["limit"]; ok {
		if limit, err := strconv.Atoi(fmt.Sprintf("%v", val)); err == nil {
			query.Limit(limit)
		}
	}

	if val, ok := queryOptions["offset"]; ok {
		if offset, err := strconv.Atoi(fmt.Sprintf("%v", val)); err == nil {
			query.Offset(offset)
		}
	}
	query.Order("id desc")
	count, err := query.SelectAndCount()
	if err != nil {
		return 0, nil, err
	}
	arrays := make([]*domain.Task, 0)
	for _, v := range m {
		d := repo.TransformToDomain(v)
		arrays = append(arrays, d)
	}
	return count, arrays, nil
}