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

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),
		CurrentStage: param.CurrentStage,
		LastStage:    param.LastStage,
	}
	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["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["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
	}
	var datas []*domain.Task
	for _, v := range m {
		d := repo.TransformToDomain(v)
		datas = append(datas, d)
	}
	return count, datas, nil
}