package service

import (
	"fmt"
	"github.com/linmadan/egglib-go/core/application"
	"github.com/linmadan/egglib-go/utils/tool_funs"
	"gitlab.fjmaimaimai.com/linmadan/mmm-worth/pkg/application/factory"
	"gitlab.fjmaimaimai.com/linmadan/mmm-worth/pkg/application/listInterval/command"
	"gitlab.fjmaimaimai.com/linmadan/mmm-worth/pkg/application/listInterval/query"
	"gitlab.fjmaimaimai.com/linmadan/mmm-worth/pkg/domain"
	"time"
)

type ListIntervalService struct {
}

// 创建排行榜时间
func (listIntervalService *ListIntervalService) CreateListInterval(createListIntervalCommand *command.CreateListIntervalCommand) (interface{}, error) {
	if err := createListIntervalCommand.ValidateCommand(); err != nil {
		return nil, application.ThrowError(application.ARG_ERROR, err.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()
	}()

	// 排行榜时间仓储初始化
	var listIntervalRepository domain.ListIntervalRepository
	if value, err := factory.CreateListIntervalRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		listIntervalRepository = value
	}

	// 获取当前最新排行榜时间
	listListIntervalQuery := &query.ListListIntervalQuery {
		CompanyId: createListIntervalCommand.CompanyId,
		Offset: 0,
		Limit: 1,
	}

	// 获取上个年榜时间
	_, listIntervals, err := listIntervalRepository.Find(tool_funs.SimpleStructToMap(listListIntervalQuery))
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

	startTime := time.Date(createListIntervalCommand.ListIntervalStartTime.Local().Year(), createListIntervalCommand.ListIntervalStartTime.Local().Month(), createListIntervalCommand.ListIntervalStartTime.Local().Day(), 0, 0, 0, 0, time.Local)
	endTime := time.Date(createListIntervalCommand.ListIntervalEndTime.Local().Year(), createListIntervalCommand.ListIntervalEndTime.Local().Month(), createListIntervalCommand.ListIntervalEndTime.Local().Day(), 23, 59, 59, 0, time.Local)


	// 判断年榜时间是否和上个年榜重叠
	if len(listIntervals) > 0 {
		if startTime.Before(listIntervals[0].IntervalEndTime.Local()) || startTime.Equal(listIntervals[0].IntervalEndTime.Local()){
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "年榜开始时间必须大于上一个年榜结束时间")
		} else {
			// 创建排行榜时间命令
			newListInterval := &domain.ListInterval {
				CompanyId: createListIntervalCommand.CompanyId,
				IntervalStartTime: startTime,
				IntervalEndTime: endTime,
			}

			// 保存排行榜时间
			listInterval, err := listIntervalRepository.Save(newListInterval)
			if err != nil {
				return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
			}
			if err := transactionContext.CommitTransaction(); err != nil {
				return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
			}

			return listInterval, nil
		}
	} else {
		// 创建排行榜时间命令
		newListInterval := &domain.ListInterval {
			CompanyId: createListIntervalCommand.CompanyId,
			IntervalStartTime: startTime,
			IntervalEndTime: endTime,
		}

		// 保存排行榜时间
		listInterval, err := listIntervalRepository.Save(newListInterval)
		if err != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
		}
		if err := transactionContext.CommitTransaction(); err != nil {
			return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
		}
		return listInterval, nil
	}
}

// 返回排行榜时间列表
func (listIntervalService *ListIntervalService) ListListInterval(listListIntervalQuery *query.ListListIntervalQuery) (interface{}, error) {
	if err := listListIntervalQuery.ValidateQuery(); err != nil {
		return nil, application.ThrowError(application.ARG_ERROR, err.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()
	}()

	var listIntervalRepository domain.ListIntervalRepository
	if value, err := factory.CreateListIntervalRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		listIntervalRepository = value
	}

	if count, listIntervals, err := listIntervalRepository.Find(tool_funs.SimpleStructToMap(listListIntervalQuery)); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		if err := transactionContext.CommitTransaction(); err != nil {
			return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
		}
		return map[string]interface{}{
			"count":       count,
			"listIntervals": listIntervals,
		}, nil
	}
}

// 返回排行榜时间
func (listIntervalService *ListIntervalService) GetListInterval(getListIntervalQuery *query.GetListIntervalQuery) (interface{}, error) {
	if err := getListIntervalQuery.ValidateQuery(); err != nil {
		return nil, application.ThrowError(application.ARG_ERROR, err.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()
	}()

	var listIntervalRepository domain.ListIntervalRepository
	if value, err := factory.CreateListIntervalRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		listIntervalRepository = value
	}

	listInterval, err := listIntervalRepository.FindOne(map[string]interface{}{"listId": getListIntervalQuery.ListIntervalId})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	if listInterval == nil {
		return nil, application.ThrowError(application.RES_NO_FIND_ERROR, fmt.Sprintf("%s", string(getListIntervalQuery.ListIntervalId)))
	} else {
		if err := transactionContext.CommitTransaction(); err != nil {
			return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
		}
		return listInterval, nil
	}
}

// 更新排行榜时间
func (listIntervalService *ListIntervalService) UpdateListInterval(updateListIntervalCommand *command.UpdateListIntervalCommand) (interface{}, error) {
	if err := updateListIntervalCommand.ValidateCommand(); err != nil {
		return nil, application.ThrowError(application.ARG_ERROR, err.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()
	}()

	var listIntervalRepository domain.ListIntervalRepository
	if value, err := factory.CreateListIntervalRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		listIntervalRepository = value
	}

	// 获取当前年榜
	listIntervalFound, err := listIntervalRepository.FindOne(map[string]interface{}{"listId": updateListIntervalCommand.ListIntervalId})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	if listIntervalFound == nil {
		return nil, application.ThrowError(application.RES_NO_FIND_ERROR, fmt.Sprintf("%s", string(updateListIntervalCommand.ListIntervalId)))
	}

	//listIntervalFoundIntervalStartTime := listIntervalFound.IntervalStartTime.Local()
	//listIntervalFoundIntervalEndTime := listIntervalFound.IntervalEndTime.Local()

	// 获取榜单命令
	listListIntervalQuery := &query.ListListIntervalQuery {
		CompanyId: listIntervalFound.CompanyId,
	}

	//获取所有年榜
	_, listIntervals, err := listIntervalRepository.Find(tool_funs.SimpleStructToMap(listListIntervalQuery))
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

	var currentListIntervalIndex int

	// 当前更新的开始结束时间
	startTime := time.Date(updateListIntervalCommand.ListIntervalStartTime.Local().Year(), updateListIntervalCommand.ListIntervalStartTime.Local().Month(), updateListIntervalCommand.ListIntervalStartTime.Local().Day(), 0, 0, 0, 0, time.Local)
	endTime := time.Date(updateListIntervalCommand.ListIntervalEndTime.Local().Year(), updateListIntervalCommand.ListIntervalEndTime.Local().Month(), updateListIntervalCommand.ListIntervalEndTime.Local().Day(), 23, 59, 59, 0, time.Local)

	updateListIntervalCommand.ListIntervalStartTime = startTime
	updateListIntervalCommand.ListIntervalEndTime = endTime

	// 判断年榜时间是否和上个年榜重叠
	if len(listIntervals) > 0 {

		// 找到当前排行榜所处位置
		for i, listInterval := range listIntervals {
			if listInterval.ListIntervalId == listIntervalFound.ListIntervalId {
				currentListIntervalIndex = i
			}
		}

		fmt.Print(currentListIntervalIndex, "\n")

		if currentListIntervalIndex == 0 && len(listIntervals) > 1 { // 当前排行榜在首位，且不止一个活动
			// 上一个活动开始结束时间
			//lastIntervalStartTime := listIntervals[currentListIntervalIndex + 1].IntervalStartTime.Local()
			lastIntervalEndTime := listIntervals[currentListIntervalIndex + 1].IntervalEndTime.Local()

			if startTime.Before(lastIntervalEndTime) || startTime.Equal(lastIntervalEndTime) {   // 开始时间重叠判断
				return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "年榜时间不能重叠")
			}
		} else if currentListIntervalIndex != 0 {  // 当前排行榜不在首位
			// 上一个年榜开始结束时间
			lastIntervalStartTime := listIntervals[currentListIntervalIndex + 1].IntervalStartTime.Local()
			lastIntervalEndTime := listIntervals[currentListIntervalIndex + 1].IntervalEndTime.Local()

			// 下一个年榜开始结束时间
			nextIntervalStartTime := listIntervals[currentListIntervalIndex - 1].IntervalStartTime.Local()
			nextIntervalEndTime := listIntervals[currentListIntervalIndex - 1].IntervalEndTime.Local()

			// 开始时间大于上一个年榜结束时间且结束时间大于下一个年榜开始时间
			if startTime.Before(lastIntervalEndTime) && endTime.After(nextIntervalEndTime) {
				return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "年榜时间不能重叠")
			}

			// 开始时间小于上一个年榜结束时间且结束时间小于下一个年榜开始时间
			if startTime.Before(lastIntervalEndTime) && endTime.Before(nextIntervalStartTime) {
				return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "年榜时间不能重叠")
			}

			// 开始时间小于上一个年榜结束时间且结束时间大于下一个年榜开始时间
			if startTime.Before(lastIntervalEndTime) && endTime.After(nextIntervalStartTime) {
				return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "年榜时间不能重叠")
			}

			// 开始时间大于下一个年榜开始时间
			if startTime.After(nextIntervalStartTime) {
				return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "年榜时间不能重叠")
			}

			// 开始时间大于下一个年榜开始时间且结束时间大于下一个年榜结束时间
			if startTime.After(nextIntervalStartTime) && endTime.After(nextIntervalEndTime) {
				return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "年榜时间不能重叠")
			}

			// 开始时间小于上一个年榜开始时间且结束时间小于上一个年榜结束时间
			if startTime.Before(lastIntervalStartTime) && endTime.Before(lastIntervalEndTime) {
				return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "年榜时间不能重叠")
			}
		}

		if err := listIntervalFound.Update(tool_funs.SimpleStructToMap(updateListIntervalCommand)); err != nil {
			return nil, application.ThrowError(application.BUSINESS_ERROR, err.Error())
		}
		if listIntervalUpdated, err := listIntervalRepository.Save(listIntervalFound); err != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
		} else {
			if err := transactionContext.CommitTransaction(); err != nil {
				return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
			}
			return listIntervalUpdated, nil
		}
	} else {  // 正常更新
		if err := listIntervalFound.Update(tool_funs.SimpleStructToMap(updateListIntervalCommand)); err != nil {
			return nil, application.ThrowError(application.BUSINESS_ERROR, err.Error())
		}
		if listIntervalUpdated, err := listIntervalRepository.Save(listIntervalFound); err != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
		} else {
			if err := transactionContext.CommitTransaction(); err != nil {
				return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
			}
			return listIntervalUpdated, nil
		}
	}
}

// 移除排行榜时间
func (listIntervalService *ListIntervalService) RemoveListInterval(removeListIntervalCommand *command.RemoveListIntervalCommand) (interface{}, error) {
	if err := removeListIntervalCommand.ValidateCommand(); err != nil {
		return nil, application.ThrowError(application.ARG_ERROR, err.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()
	}()

	var listIntervalRepository domain.ListIntervalRepository
	if value, err := factory.CreateListIntervalRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		listIntervalRepository = value
	}

	listInterval, err := listIntervalRepository.FindOne(map[string]interface{}{"listId": removeListIntervalCommand.ListIntervalId})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	if listInterval == nil {
		return nil, application.ThrowError(application.RES_NO_FIND_ERROR, fmt.Sprintf("%s", string(removeListIntervalCommand.ListIntervalId)))
	}

	if listInterval, err := listIntervalRepository.Remove(listInterval); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		if err := transactionContext.CommitTransaction(); err != nil {
			return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
		}
		return listInterval, nil
	}
}

func NewListIntervalService(options map[string] interface{}) *ListIntervalService {
	newListIntervalService := &ListIntervalService{}
	return newListIntervalService
}