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 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,
		RelatedUser: d.RelatedUser,
		RunAt:       d.RunAt,
		StopAt:      d.StopAt,
		Anomaly:     d.Anomaly,
		WarnFlag:    domain.TaskWarnFlag(d.WarnFlag),
	}
}

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,
		RunAt:       param.RunAt,
		StopAt:      param.StopAt,
		Anomaly:     param.Anomaly,
		WarnFlag:    int(param.WarnFlag),
	}
	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["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)
	}
	query.Order("id desc")
	count, err := query.SelectAndCount()
	if err != nil {
		return 0, nil, err
	}
	var datas []*domain.Task
	for _, v := range m {
		d := repo.TransformToDomain(v)
		datas = append(datas, d)
	}
	return count, datas, nil
}