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"
	"gitlab.fjmaimaimai.com/linmadan/mmm-worth/pkg/infrastructure/dao"
	"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
	}

	// 排行榜管理DAO初始化
	var listIntervalDao *dao.ListIntervalDao
	if value, err := factory.CreateListIntervalDao(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	} else {
		listIntervalDao = 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)

	ok := listIntervalDao.RankPeriodCheckTime(startTime.UnixNano() / 1e6, endTime.UnixNano() / 1e6, 0)
	if !ok {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "年榜时间不能重叠")
	}

	// 判断年榜时间是否和上个年榜重叠
	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
	}

	// 排行榜管理DAO初始化
	var listIntervalDao *dao.ListIntervalDao
	if value, err := factory.CreateListIntervalDao(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	} else {
		listIntervalDao = 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)))
	}

	//// 获取所有年榜
	//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

	ok := listIntervalDao.RankPeriodCheckTime(startTime.UnixNano() / 1e6, endTime.UnixNano() / 1e6, listIntervalFound.ListIntervalId)
	if !ok {
		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
	}

	// 判断年榜时间是否和上个年榜重叠
	//if len(listIntervals) > 0 {
	//	// 找到当前排行榜所处位置
	//	for i, listInterval := range listIntervals {
	//		if listInterval.ListIntervalId == listIntervalFound.ListIntervalId {
	//			currentListIntervalIndex = i
	//		}
	//	}
	//
	//	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 {  // 当前排行榜不在首位
	//		fmt.Print(currentListIntervalIndex, "\n")
	//
	//		// 上一个年榜开始结束时间
	//		lastIntervalStartTime := listIntervals[currentListIntervalIndex + 1].IntervalStartTime.Local()
	//		lastIntervalEndTime := listIntervals[currentListIntervalIndex + 1].IntervalEndTime.Local()
	//		fmt.Print(lastIntervalEndTime,"\n")
	//
	//		// 下一个年榜开始结束时间
	//		nextIntervalStartTime := listIntervals[currentListIntervalIndex - 1].IntervalStartTime.Local()
	//		fmt.Print(nextIntervalStartTime, "\n")
	//		nextIntervalEndTime := listIntervals[currentListIntervalIndex - 1].IntervalEndTime.Local()
	//
	//		fmt.Print(startTime, "\n")
	//		fmt.Print(endTime, "\n")
	//
	//		if startTime.After(lastIntervalStartTime) && startTime.Before(lastIntervalEndTime) || endTime.After(nextIntervalStartTime) && endTime.Before(nextIntervalEndTime) {
	//			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
}