// Package service 业务逻辑层
package service

import (
	"server/modules/user/vo"
	"server/modules/yx/dto"
	"server/modules/yx/entity"
	"server/modules/yx/mapper"

	"github.com/google/uuid"
)

type YxCalculationMajorService struct {
	historyMajorEnrollService *YxHistoryMajorEnrollService
	mapper                    *mapper.YxCalculationMajorMapper
}

func NewYxCalculationMajorService() *YxCalculationMajorService {
	return &YxCalculationMajorService{
		historyMajorEnrollService: NewYxHistoryMajorEnrollService(),
		mapper:                    mapper.NewYxCalculationMajorMapper(),
	}
}

func (s *YxCalculationMajorService) List(page, size int) ([]entity.YxCalculationMajor, int64, error) {
	return s.mapper.FindAll(page, size)
}

func (s *YxCalculationMajorService) GetByID(id string) (*entity.YxCalculationMajor, error) {
	return s.mapper.FindByID(id)
}

func (s *YxCalculationMajorService) Create(item *entity.YxCalculationMajor) error {
	item.ID = uuid.New().String()
	return s.mapper.Create(item)
}

func (s *YxCalculationMajorService) Update(item *entity.YxCalculationMajor) error {
	return s.mapper.Update(item)
}

func (s *YxCalculationMajorService) UpdateFields(id string, fields map[string]interface{}) error {
	return s.mapper.UpdateFields(id, fields)
}

func (s *YxCalculationMajorService) Delete(id string) error {
	return s.mapper.Delete(id)
}

func (s *YxCalculationMajorService) GetByScoreID(scoreID string) ([]entity.YxCalculationMajor, error) {
	return s.mapper.FindByScoreID(scoreID)
}

func (s *YxCalculationMajorService) BatchCreate(items []entity.YxCalculationMajor) error {
	for i := range items {
		items[i].ID = uuid.New().String()
	}
	return s.mapper.BatchCreate(items, 100)
}

func (s *YxCalculationMajorService) BatchUpdate(items []entity.YxCalculationMajor) error {
	return s.mapper.BatchUpdate(items)
}

func (s *YxCalculationMajorService) BatchUpsert(items []entity.YxCalculationMajor, updateColumns []string) error {
	for i := range items {
		if items[i].ID == "" {
			items[i].ID = uuid.New().String()
		}
	}
	return s.mapper.BatchUpsert(items, updateColumns)
}

func (s *YxCalculationMajorService) BatchDelete(ids []string) error {
	return s.mapper.BatchDelete(ids)
}

func (s *YxCalculationMajorService) DeleteByScoreID(scoreID string) error {
	return s.mapper.DeleteByScoreID(scoreID)
}

// 函数名 根据用户查询类型获取专业列表
// 详细描述（可选）
//
// 参数说明:
//
//		professionalCategory - 专业分类
//		cognitioPolyclinic - 文理文科
//	 	professionalCategoryChildren - 专业分类子项
//
// 返回值说明:
//
//	返回值类型 - 返回值描述
func (s *YxCalculationMajorService) ListByUserQueryType(professionalCategory string, cognitioPolyclinic string,
	professionalCategoryChildren []string) ([]dto.SchoolMajorDTO, error) {
	// 构造查询条件
	query := dto.SchoolMajorQuery{
		MajorType: professionalCategory,
		Category:  cognitioPolyclinic,
		// MainSubjects: "器乐",
		// MajorTypeChildren: []string{
		// 	"音乐教育",
		// },
	}
	years := []string{"2025", "2024"}

	// 执行院校查询
	majorItems, err := mapper.NewYxSchoolMajorMapper().SelectSchoolMajor(query)
	if err != nil {
		return nil, err
	}
	// 分别收集专业名称和院校代码集合（去重）
	majorNameSet := make(map[string]bool)
	schoolCodeSet := make(map[string]bool)
	for _, dto := range majorItems {
		majorNameSet[dto.MajorName] = true
		schoolCodeSet[dto.SchoolCode] = true
	}
	// 转换为切片用于查询
	majorNames := make([]string, 0, len(majorNameSet))
	schoolCodes := make([]string, 0, len(schoolCodeSet))
	for name := range majorNameSet {
		majorNames = append(majorNames, name)
	}
	for code := range schoolCodeSet {
		schoolCodes = append(schoolCodes, code)
	}
	// 执行查询院校专业的历年数据 - 类似Java中的in查询
	historyItems, err := s.historyMajorEnrollService.ListBySchoolCodesAndMajorNames(
		schoolCodes,
		majorNames,
		query.Category,  // 文科/理科
		query.MajorType, // 专业类型
		years,           // 年份
	)

	if err != nil {
		return nil, err
	}

	// 构建历史数据映射：schoolCode_majorName_batch_year -> historyItem
	allHistoryMajorEnrollMap := make(map[string]entity.YxHistoryMajorEnroll)
	for _, historyItem := range historyItems {
		key := historyItem.SchoolCode + "_" + historyItem.MajorName + "_" + historyItem.Batch + "_" + historyItem.Year
		allHistoryMajorEnrollMap[key] = historyItem
	}
	// 将历史数据填充到每个专业数据中
	for i, majorItem := range majorItems {
		// 为每个majorItem创建独立的历史数据映射
		historyMap := make(map[string]dto.YxHistoryMajorEnrollDTO)

		for _, year := range years {
			key := majorItem.SchoolCode + "_" + majorItem.MajorName + "_" + majorItem.Batch + "_" + year
			if historyItem, ok := allHistoryMajorEnrollMap[key]; ok {
				// 类型转换：entity -> dto
				dtoItem := dto.YxHistoryMajorEnrollDTO{
					Year:                   historyItem.Year,
					EnrollmentCode:         historyItem.EnrollmentCode,
					RulesEnrollProbability: historyItem.RulesEnrollProbability,
					ProbabilityOperator:    historyItem.ProbabilityOperator,
					AdmissionLine:          historyItem.AdmissionLine,
					ControlLine:            historyItem.ControlLine,
					// 复制其他需要的字段
				}
				historyMap[year] = dtoItem
			}
		}
		majorItems[i].HistoryMajorEnrollMap = historyMap
	}

	return majorItems, nil
}

// 函数名 给专业列表计算录取率
// 详细描述（可选）
//
// 参数说明:
//
//		schoolMajorDTOList - 专业列表
//		professionalCategory - 专业分类
//		cognitioPolyclinic - 文理文科
//	 	professionalCategoryChildren - 专业分类子项
//
// 返回值说明:
//
//	返回值类型 - 返回值描述
func (s *YxCalculationMajorService) CheckEnrollProbability(schoolMajorDTOList *[]dto.SchoolMajorDTO, userScoreVO vo.UserScoreVO) error {

	return nil
}