package service

import (
	"errors"
	"strings"

	"github.com/sirupsen/logrus"
	"myschools.me/heritage/heritage-api/model"
	"myschools.me/heritage/heritage-api/mysql"
)

func TaskCreateTask(t *model.Task) (*model.Task, error) {
	if t == nil {
		return nil, errors.New("invalid task")
	}
	t.ID = strings.TrimSpace(t.ID)
	if t.ID == "" {
		t.ID = newID()
	}
	t.Name = strings.TrimSpace(t.Name)
	t.OrgID = strings.TrimSpace(t.OrgID)
	t.ProjectID = strings.TrimSpace(t.ProjectID)
	t.ObjectIDs = strings.TrimSpace(t.ObjectIDs)
	t.TypeCode = strings.TrimSpace(t.TypeCode)
	t.IndicatorIDs = strings.TrimSpace(t.IndicatorIDs)
	t.PackageIDs = strings.TrimSpace(t.PackageIDs)
	t.ExecutorPersonID = strings.TrimSpace(t.ExecutorPersonID)
	t.ConfirmerPersonID = strings.TrimSpace(t.ConfirmerPersonID)
	t.StatusCode = strings.TrimSpace(t.StatusCode)
	t.Remark = strings.TrimSpace(t.Remark)

	if t.ObjectIDs == "" || t.TypeCode == "" || t.ExecutorPersonID == "" || t.ConfirmerPersonID == "" || t.StatusCode == "" {
		return nil, errors.New("missing required fields")
	}

	if err := mysql.TaskCreate(t); err != nil {
		logrus.WithFields(logrus.Fields{
			"func": "TaskCreateTask",
		}).Warnf("mysql.TaskCreate: %v", err)
		return nil, err
	}
	return t, nil
}

func TaskUpdateTask(idv string, patch *model.Task) (*model.Task, error) {
	tid := strings.TrimSpace(idv)
	if tid == "" {
		return nil, ErrNotFound
	}
	existing, found, err := mysql.TaskByID(&tid)
	if err != nil {
		logrus.WithFields(logrus.Fields{
			"func": "TaskUpdateTask",
		}).Warnf("mysql.TaskByID: %v", err)
		return nil, err
	}
	if !found || existing == nil {
		logrus.WithFields(logrus.Fields{
			"func": "TaskUpdateTask",
		}).Warnf("mysql.TaskByID: not found")
		return nil, ErrNotFound
	}
	if patch == nil {
		return existing, nil
	}

	if s := strings.TrimSpace(patch.Name); s != "" {
		existing.Name = s
	}
	if s := strings.TrimSpace(patch.OrgID); s != "" {
		existing.OrgID = s
	}
	if s := strings.TrimSpace(patch.ProjectID); s != "" {
		existing.ProjectID = s
	}
	if s := strings.TrimSpace(patch.ObjectIDs); s != "" {
		existing.ObjectIDs = s
	}
	if s := strings.TrimSpace(patch.TypeCode); s != "" {
		existing.TypeCode = s
	}
	if s := strings.TrimSpace(patch.IndicatorIDs); s != "" {
		existing.IndicatorIDs = s
	}
	if s := strings.TrimSpace(patch.PackageIDs); s != "" {
		existing.PackageIDs = s
	}
	if s := strings.TrimSpace(patch.ExecutorPersonID); s != "" {
		existing.ExecutorPersonID = s
	}
	if s := strings.TrimSpace(patch.ConfirmerPersonID); s != "" {
		existing.ConfirmerPersonID = s
	}
	if !patch.StartAt.IsZero() {
		existing.StartAt = patch.StartAt
	}
	if !patch.EndAt.IsZero() {
		existing.EndAt = patch.EndAt
	}
	if patch.ExecutedAt != nil {
		t := *patch.ExecutedAt
		existing.ExecutedAt = &t
	}
	existing.SinglePoint = patch.SinglePoint
	if patch.PeriodicType != 0 {
		existing.PeriodicType = patch.PeriodicType
	}
	if patch.PeriodDays != 0 {
		existing.PeriodDays = patch.PeriodDays
	}
	if s := strings.TrimSpace(patch.StatusCode); s != "" {
		existing.StatusCode = s
	}
	if s := strings.TrimSpace(patch.Remark); s != "" {
		existing.Remark = s
	}

	ok, err := mysql.TaskUpdate(existing)
	if err != nil {
		logrus.WithFields(logrus.Fields{
			"func": "TaskUpdateTask",
		}).Warnf("mysql.TaskUpdate: %v", err)
		return nil, err
	}
	if !ok {
		logrus.WithFields(logrus.Fields{
			"func": "TaskUpdateTask",
		}).Warnf("mysql.TaskUpdate: not found")
		return nil, ErrNotFound
	}
	return existing, nil
}

func TaskDeleteTask(idv string) error {
	tid := strings.TrimSpace(idv)
	if tid == "" {
		return ErrNotFound
	}
	ok, err := mysql.TaskDelete(&tid)
	if err != nil {
		logrus.WithFields(logrus.Fields{
			"func": "TaskDeleteTask",
		}).Warnf("mysql.TaskDelete: %v", err)
		return err
	}
	if !ok {
		logrus.WithFields(logrus.Fields{
			"func": "TaskDeleteTask",
		}).Warnf("mysql.TaskDelete: not found")
		return ErrNotFound
	}
	return nil
}

func TaskGetTask(idv string) (*model.Task, error) {
	tid := strings.TrimSpace(idv)
	if tid == "" {
		return nil, ErrNotFound
	}
	t, found, err := mysql.TaskByID(&tid)
	if err != nil {
		logrus.WithFields(logrus.Fields{
			"func": "TaskGetTask",
		}).Warnf("mysql.TaskByID: %v", err)
		return nil, err
	}
	if !found || t == nil {
		logrus.WithFields(logrus.Fields{
			"func": "TaskGetTask",
		}).Warnf("mysql.TaskByID: not found")
		return nil, ErrNotFound
	}
	return t, nil
}

func TaskListTasks(projectID, keyword *string, page, size int) ([]model.Task, int64, error) {
	if page < 1 {
		page = 1
	}
	if size < 1 {
		size = 20
	}
	if size > 200 {
		size = 200
	}
	offset := (page - 1) * size
	return mysql.TaskList(projectID, keyword, &offset, &size)
}