package service

import (
	"strconv"
	"time"

	"github.com/linmadan/egglib-go/core/application"
	"github.com/linmadan/egglib-go/utils/tool_funs"
	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/application/factory"
	roleService "gitlab.fjmaimaimai.com/allied-creation/performance/pkg/application/role"
	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/application/task/adapter"
	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/application/task/command"
	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/domain"
	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/infrastructure/dao"
)

type TaskService struct{}

func NewTaskService() *TaskService {
	newService := &TaskService{}
	return newService
}

func dayEndTime(t time.Time) time.Time {
	y, m, d := t.Local().Date()
	t2 := time.Date(y, m, d, 23, 59, 59, 0, time.Local)
	return t2
}

func (srv TaskService) CreateTaskTest(param *command.CreateTaskCommand) error {
	transactionContext, err := factory.CreateTransactionContext(nil)
	if err != nil {
		return application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	if err := transactionContext.StartTransaction(); err != nil {
		return application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	defer func() {
		_ = transactionContext.RollbackTransaction()
	}()
	err = srv.CreateTask(transactionContext, param)
	if err != nil {
		return application.ThrowError(application.INTERNAL_SERVER_ERROR, "创建任务失败:"+err.Error())
	}
	if err := transactionContext.CommitTransaction(); err != nil {
		return application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	return nil
}

func (srv TaskService) CreateTask(transactionContext application.TransactionContext, param *command.CreateTaskCommand) error {
	taskRepo := factory.CreateTaskRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	taskStageRepo := factory.CreateTaskStageRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	cnt, _, err := taskRepo.Find(map[string]interface{}{
		"name":     param.Name,
		"leaderId": param.LeaderId,
	})
	if err != nil {
		return application.ThrowError(application.INTERNAL_SERVER_ERROR, "查询任务失败:"+err.Error())
	}
	if cnt > 0 {
		//TODO
		//任务已存在
		return nil
	}
	userRepo := factory.CreateUserRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})

	_, leaderList, err := userRepo.Find(map[string]interface{}{
		"id": param.LeaderId,
	})
	if err != nil {
		return application.ThrowError(application.INTERNAL_SERVER_ERROR, "查询人员失败:"+err.Error())
	}
	if len(leaderList) == 0 {
		return application.ThrowError(application.INTERNAL_SERVER_ERROR, "没有查询到人员")
	}
	leaderData := leaderList[0]
	nowTime := time.Now()
	newTask := domain.Task{
		Id:        0,
		CreatedAt: time.Time{},
		UpdatedAt: time.Time{},
		DeletedAt: nil,
		CompanyId: int(leaderData.CompanyId),
		Name:      param.Name,
		Alias:     param.Name,
		Leader: domain.TaskLeader{
			Id:      leaderData.Id,
			Account: leaderData.Account,
			Name:    leaderData.Name,
		},
		Status:      domain.TaskWait,
		Level:       0,
		LevelName:   "",
		RelatedUser: []int{},
		RunAt:       nowTime.Unix(),
		StopAt:      0,
	}
	newTask.ApplyLevelName("战略任务")
	err = taskRepo.Save(&newTask)
	if err != nil {
		return application.ThrowError(application.INTERNAL_SERVER_ERROR, "创建任务失败:"+err.Error())
	}

	nowEndTime := dayEndTime(nowTime)

	newTaskStage := []*domain.TaskStage{
		{
			Id:              0,
			TaskId:          newTask.Id,
			Name:            "里程碑1",
			SortBy:          1,
			Status:          domain.TaskStageUncompleted,
			PlanCompletedAt: nowEndTime.Add(30 * 24 * time.Hour).Unix(),
			RealCompletedAt: 0,
		},
		{
			Id:              0,
			TaskId:          newTask.Id,
			Name:            "里程碑2",
			SortBy:          2,
			Status:          domain.TaskStageUncompleted,
			PlanCompletedAt: nowEndTime.Add(60 * 24 * time.Hour).Unix(),
			RealCompletedAt: 0,
		},
		{
			Id:              0,
			TaskId:          newTask.Id,
			Name:            "里程碑3",
			SortBy:          3,
			Status:          domain.TaskStageUncompleted,
			PlanCompletedAt: nowEndTime.Add(90 * 24 * time.Hour).Unix(),
			RealCompletedAt: 0,
		},
	}
	err = taskStageRepo.Save(newTaskStage)
	if err != nil {
		return application.ThrowError(application.INTERNAL_SERVER_ERROR, "创建任务失败:"+err.Error())
	}
	return nil
}

// 更新任务
// TODO 检查是否可以修改，和通知
func (srv TaskService) UpdateTask(param *command.UpdateTaskCommand) (map[string]interface{}, error) {
	transactionContext, err := factory.CreateTransactionContext(nil)
	if err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	if err := transactionContext.StartTransaction(); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	defer func() {
		_ = transactionContext.RollbackTransaction()
	}()
	if len(param.StageList) < 3 {
		return map[string]interface{}{
			"id": param.Id,
		}, application.ThrowError(application.INTERNAL_SERVER_ERROR, "里程碑数量至少3个")
	}
	if len(param.StageList) > 5 {
		return map[string]interface{}{
			"id": param.Id,
		}, application.ThrowError(application.INTERNAL_SERVER_ERROR, "里程碑数量太多")
	}
	taskRepo := factory.CreateTaskRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	userRepo := factory.CreateUserRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	taskStageRepo := factory.CreateTaskStageRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	taskData, err := taskRepo.FindOne(map[string]interface{}{
		"id": param.Id,
	})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	_, stageList, err := taskStageRepo.Find(map[string]interface{}{
		"taskId": param.Id,
	})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	//任务的相关人员
	relatedUserIds := []int{}
	for _, val := range param.RelatedUserId {
		id, _ := strconv.Atoi(val)
		relatedUserIds = append(relatedUserIds, id)
	}
	var relatedUser []*domain.User
	if len(relatedUserIds) > 0 {
		_, relatedUser, err = userRepo.Find(map[string]interface{}{
			"ids": relatedUserIds,
		})
		if err != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "获取任务的相关人员"+err.Error())
		}
	}
	ok, err := srv.canUpdateTask(taskData, stageList)
	if err != nil {
		return nil, err
	}
	if !ok {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "日评数据已生成，任务不能再被编辑")
	}
	//更新相关人员
	taskData.RelatedUser = []int{}
	for _, val := range relatedUser {
		taskData.RelatedUser = append(taskData.RelatedUser, int(val.Id))
	}
	//更新任务名称
	taskData.Alias = param.Alias
	taskData.ApplyLevelName(param.LevelName)
	nowTime := time.Now()
	stageMap := map[int]*domain.TaskStage{}
	for _, val := range stageList {
		val.DeletedAt = &nowTime
		stageMap[val.Id] = val
	}
	lastPlanCompletedAt := time.Time{}
	newStageList := []*domain.TaskStage{}
	for i, val2 := range param.StageList {
		t, err := time.ParseInLocation("2006-01-02", val2.PlanCompletedAt, time.Local)
		if err != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "请填写里程碑完成时间")
		}
		if i > 0 {
			if lastPlanCompletedAt.After(t) {
				return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "里程碑["+val2.Name+"]完成时间填写错误")
			}
		}
		lastPlanCompletedAt = t
		if val2.Id == 0 {
			newStage := domain.TaskStage{
				Id:              0,
				TaskId:          taskData.Id,
				Name:            val2.Name,
				SortBy:          i + 1,
				Status:          domain.TaskStageUncompleted,
				PlanCompletedAt: t.Unix(),
				RealCompletedAt: 0,
			}
			newStageList = append(newStageList, &newStage)
			continue
		}
		oldStage, ok := stageMap[val2.Id]
		if !ok {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "里程碑数据被其他人变更")
		}
		oldStage.DeletedAt = nil
		oldStage.SortBy = i + 1
		oldStage.Name = val2.Name
		oldStage.PlanCompletedAt = t.Unix()
		//TODO 修改里程碑计划完成时间，特殊处理
	}
	stageList = append(stageList, newStageList...)

	err = taskStageRepo.Save(stageList)
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	err = taskRepo.Save(taskData)
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	if err := transactionContext.CommitTransaction(); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	return map[string]interface{}{
		"id": param.Id,
	}, nil
}

// 获取任务详情
func (srv TaskService) GetTaskInfo(param *command.GetTaskCommand) (*adapter.TaskInfoAdapter, error) {
	transactionContext, err := factory.CreateTransactionContext(nil)
	if err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	if err := transactionContext.StartTransaction(); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	defer func() {
		_ = transactionContext.RollbackTransaction()
	}()
	taskRepo := factory.CreateTaskRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	taskStageRepo := factory.CreateTaskStageRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	userRepo := factory.CreateUserRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	taskData, err := taskRepo.FindOne(map[string]interface{}{
		"id": param.TaskId,
	})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	_, stageList, err := taskStageRepo.Find(map[string]interface{}{
		"taskId": param.TaskId,
	})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

	relatedUserId := taskData.RelatedUser
	var relatedUserList []*domain.User
	if len(relatedUserId) > 0 {
		_, relatedUserList, err = userRepo.Find(map[string]interface{}{
			"ids": relatedUserId,
		})
		if err != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "获取相关人员"+err.Error())
		}
	}
	if err := transactionContext.CommitTransaction(); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

	result := adapter.TaskInfoAdapter{
		Id:       taskData.Id,
		Name:     taskData.Name,
		Alias:    taskData.Alias,
		LeaderId: taskData.Leader.Id,
		Leader: adapter.UserData{
			Id:      taskData.Leader.Id,
			Account: taskData.Leader.Account,
			Name:    taskData.Leader.Name,
		},
		Status:            int(taskData.Status),
		StatusDescription: taskData.StatusDescription(),
		Level:             taskData.Level,
		LevalName:         taskData.LevelName,
		RelatedUserId:     []string{},
		RelatedUser:       []adapter.UserData{},
		StageList:         []adapter.TaskStage{},
	}
	for _, val := range relatedUserList {
		idStr := strconv.Itoa(int(val.Id))
		result.RelatedUserId = append(result.RelatedUserId, idStr)
		result.RelatedUser = append(result.RelatedUser, adapter.UserData{
			Id:      val.Id,
			Account: val.Account,
			Name:    val.Name,
		})
	}

	for _, val := range stageList {
		t1 := ""
		t2 := ""
		if val.PlanCompletedAt > 0 {
			t1 = time.Unix(val.PlanCompletedAt, 0).Local().Format("2006-01-02")
		}
		if val.RealCompletedAt > 0 {
			t2 = time.Unix(val.RealCompletedAt, 0).Local().Format("2006-01-02")
		}
		result.StageList = append(result.StageList, adapter.TaskStage{
			Id:                val.Id,
			Name:              val.Name,
			PlanCompletedAt:   t1,
			RealCompletedAt:   t2,
			SortBy:            val.SortBy,
			StatusDescription: val.StatusDescription(),
			Status:            int(val.Status),
		})
	}
	return &result, nil
}

// RunTask 启动任务
func (srv TaskService) RunTask(param *command.RunTaskCommand) (map[string]interface{}, error) {
	transactionContext, err := factory.CreateTransactionContext(nil)
	if err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	if err := transactionContext.StartTransaction(); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	defer func() {
		_ = transactionContext.RollbackTransaction()
	}()
	taskRepo := factory.CreateTaskRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	taskData, err := taskRepo.FindOne(map[string]interface{}{
		"id": param.TaskId,
	})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	if taskData.Status == domain.TaskRunning {
		return map[string]interface{}{"id": param.TaskId}, nil
	}

	taskData.Status = domain.TaskRunning
	taskData.RunAt = time.Now().Unix()
	err = taskRepo.Save(taskData)
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "保存任务数据"+err.Error())
	}
	if err := transactionContext.CommitTransaction(); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	return map[string]interface{}{"id": param.TaskId}, nil
}

// RunTask 停止任务
func (srv TaskService) StopTask(param *command.StopTaskCommand) (map[string]interface{}, error) {
	transactionContext, err := factory.CreateTransactionContext(nil)
	if err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	if err := transactionContext.StartTransaction(); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	defer func() {
		_ = transactionContext.RollbackTransaction()
	}()
	taskRepo := factory.CreateTaskRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	taskData, err := taskRepo.FindOne(map[string]interface{}{
		"id": param.TaskId,
	})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	if taskData.Status == domain.TaskStop {
		return map[string]interface{}{"id": param.TaskId}, nil
	}

	taskData.Status = domain.TaskStop
	taskData.StopAt = time.Now().Unix()
	err = taskRepo.Save(taskData)
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "保存任务数据"+err.Error())
	}
	if err := transactionContext.CommitTransaction(); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	return map[string]interface{}{"id": param.TaskId}, nil
}

// ListTask 任务列表
func (srv TaskService) ListTask(param *command.ListTaskCommand) (map[string]interface{}, error) {
	transactionContext, err := factory.CreateTransactionContext(nil)
	if err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	if err := transactionContext.StartTransaction(); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	defer func() {
		_ = transactionContext.RollbackTransaction()
	}()
	taskRepo := factory.CreateTaskRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	taskStageRepo := factory.CreateTaskStageRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	//
	condition := map[string]interface{}{
		"offset":    0,
		"limit":     20,
		"companyId": param.CompanyId,
	}
	if len(param.SearchWord) > 0 {
		condition["aliasOrLeader"] = "%" + param.SearchWord + "%"
	}
	if param.PageSize > 0 {
		condition["limit"] = param.PageSize
		if param.PageNumber > 0 {
			condition["offset"] = (param.PageNumber - 1) * param.PageSize
		}
	}

	taskCnt, taskList, err := taskRepo.Find(condition)
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "查询任务数据"+err.Error())
	}
	taskIdList := []int{}
	for _, val := range taskList {
		taskIdList = append(taskIdList, val.Id)
	}

	_, stageList, err := taskStageRepo.Find(map[string]interface{}{
		"taskIdList": taskIdList,
	})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "查询任务阶段数据"+err.Error())
	}
	if err := transactionContext.CommitTransaction(); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

	taskResult := []*adapter.TaskItem{}
	taskMapResult := map[int]*adapter.TaskItem{}
	for _, val := range taskList {
		tk := adapter.TaskItem{
			Id:        val.Id,
			Name:      val.Name,
			Alias:     val.Alias,
			Leader:    val.Leader.Name,
			Status:    int(val.Status),
			Level:     val.Level,
			LevelName: val.LevelName,
			// StageA:    adapter.TaskStage{},
			// StageB:    adapter.TaskStage{},
			// StageC:    adapter.TaskStage{},
			// StageD:    adapter.TaskStage{},
			// StageE:    adapter.TaskStage{},
		}
		taskResult = append(taskResult, &tk)
		taskMapResult[val.Id] = &tk
	}
	for _, val := range stageList {
		taskData, ok := taskMapResult[val.TaskId]
		if !ok {
			continue
		}
		stage := adapter.TaskStage{
			Id:                val.Id,
			Name:              val.Name,
			StatusDescription: val.StatusDescription(),
			Status:            int(val.Status),
			SortBy:            val.SortBy,
		}
		switch val.SortBy {
		case 1:
			taskData.StageA = stage
		case 2:
			taskData.StageB = stage
		case 3:
			taskData.StageC = stage
		case 4:
			taskData.StageD = stage
		case 5:
			taskData.StageE = stage
		}
	}
	result := tool_funs.SimpleWrapGridMap(int64(taskCnt), taskResult)
	return result, nil
}

func (t TaskService) canUpdateTask(taskData *domain.Task, stageList []*domain.TaskStage) (bool, error) {
	return true, nil
}

// CancelAttention 用户取消关注某个任务
func (t TaskService) CancelAttention(param *command.CancelAttentionCommand) error {
	transactionContext, err := factory.CreateTransactionContext(nil)
	if err != nil {
		return application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	if err := transactionContext.StartTransaction(); err != nil {
		return application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	defer func() {
		_ = transactionContext.RollbackTransaction()
	}()
	taskIgnoreRepo := factory.CreateTaskIgnoreRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	taskIgnore := domain.TaskIgnore{
		Id:        0,
		TaskId:    param.TaskId,
		UserId:    param.UserId,
		CreatedAt: time.Time{},
	}
	err = taskIgnoreRepo.Save(&taskIgnore)
	if err != nil {
		return application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	if err := transactionContext.CommitTransaction(); err != nil {
		return application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	return nil
}

// 员工绩效-任务管理-列表
func (t TaskService) ListTask2(param command.SearchTaskCommand) (map[string]interface{}, error) {
	transactionContext, err := factory.CreateTransactionContext(nil)
	if err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	if err := transactionContext.StartTransaction(); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	defer func() {
		_ = transactionContext.RollbackTransaction()
	}()
	hrbpFlag, err := roleService.GetHrBp(transactionContext, int(param.CompanyId), int(param.UserId))
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "获取用户的角色信息"+err.Error())
	}
	var limit = 20
	var offset = 0
	if param.PageSize > 0 {
		limit = param.PageSize
		if param.PageNumber > 0 {
			offset = (param.PageNumber - 1) * param.PageSize
		}
	}
	condition := dao.ListTaskCondition{
		Limit:     limit,
		Offset:    offset,
		UserId:    param.UserId,
		TaskName:  param.TaskName,
		LevelName: param.LevelName,
		OnlyMy:    param.OnlyMy,
		LeaderId:  param.LeaderId,
	}

	if hrbpFlag == domain.RoleTypeSystem {
		//已hrbp权限获取
		// info.IsHrbp = true
		return nil, nil
	}
	taskDato := dao.NewTaskDao(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	taskDato.ListTaskStageNotHrbp(condition)
	if err := transactionContext.CommitTransaction(); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	return nil, nil
}

// 以hrbp角色权限获取任务列表
func (t TaskService) ListTask2ForHrbp(param command.SearchTaskCommand) (map[string]interface{}, error) {
	return nil, nil
}