package repository

import (
	"sort"
	"strconv"

	"gitlab.com/mbugroup/lti-api.git/internal/common/repository"
	entity "gitlab.com/mbugroup/lti-api.git/internal/entities"
	utils "gitlab.com/mbugroup/lti-api.git/internal/utils"
	approvalutils "gitlab.com/mbugroup/lti-api.git/internal/utils/approvals"
	"gorm.io/gorm"
)

type ConstantRepository interface {
	GetConstants() (map[string]interface{}, error)
}

type ConstantRepositoryImpl struct {
	*repository.BaseRepositoryImpl[entity.Constant]
}

func NewConstantRepository(db *gorm.DB) ConstantRepository {
	return &ConstantRepositoryImpl{
		BaseRepositoryImpl: repository.NewBaseRepository[entity.Constant](db),
	}
}

func (r *ConstantRepositoryImpl) GetConstants() (map[string]interface{}, error) {
	flagSet := make(map[string]struct{})
	for _, f := range utils.AllowedFlagTypes(utils.FlagGroupProduct) {
		flagSet[string(f)] = struct{}{}
	}
	for _, f := range utils.AllowedFlagTypes(utils.FlagGroupNonstock) {
		flagSet[string(f)] = struct{}{}
	}
	flagSet[string(utils.FlagIsActive)] = struct{}{}

	flagList := make([]string, 0, len(flagSet))
	for f := range flagSet {
		flagList = append(flagList, f)
	}
	sort.Strings(flagList)

	legacyFlagAliasesRaw := utils.LegacyFlagTypeAliases()
	legacyFlagAliases := make(map[string]string, len(legacyFlagAliasesRaw))
	for legacy, canonical := range legacyFlagAliasesRaw {
		legacyFlagAliases[string(legacy)] = string(canonical)
	}

	productFlagOptionsRaw := utils.ProductFlagOptions()
	productFlagOptions := make([]map[string]interface{}, 0, len(productFlagOptionsRaw))
	productMainFlags := make([]string, 0, len(productFlagOptionsRaw))
	productSubFlagToFlag := make(map[string]string)
	for _, option := range productFlagOptionsRaw {
		flag := string(option.Flag)
		productMainFlags = append(productMainFlags, flag)

		subFlags := make([]string, len(option.SubFlags))
		for i, subFlag := range option.SubFlags {
			subFlagStr := string(subFlag)
			subFlags[i] = subFlagStr
			productSubFlagToFlag[subFlagStr] = flag
		}

		productFlagOptions = append(productFlagOptions, map[string]interface{}{
			"flag":                   flag,
			"sub_flags":              subFlags,
			"allow_without_sub_flag": option.AllowWithoutSubFlag,
		})
	}

	type approvalStepConstant struct {
		StepNumber uint16 `json:"step_number"`
		StepName   string `json:"step_name"`
	}

	workflowConstants := approvalutils.WorkflowConstants()
	workflowKeys := make([]string, 0, len(workflowConstants))
	for key := range workflowConstants {
		workflowKeys = append(workflowKeys, key)
	}
	sort.Strings(workflowKeys)

	approvalWorkflows := make([]map[string]interface{}, 0, len(workflowKeys))
	for _, key := range workflowKeys {
		stepMap := workflowConstants[key]
		if len(stepMap) == 0 {
			continue
		}

		stepList := make([]approvalStepConstant, 0, len(stepMap))
		for stepStr, label := range stepMap {
			stepNum, err := strconv.ParseUint(stepStr, 10, 16)
			if err != nil || stepNum == 0 {
				continue
			}
			stepList = append(stepList, approvalStepConstant{
				StepNumber: uint16(stepNum),
				StepName:   label,
			})
		}
		if len(stepList) == 0 {
			continue
		}
		sort.Slice(stepList, func(i, j int) bool {
			return stepList[i].StepNumber < stepList[j].StepNumber
		})

		approvalWorkflows = append(approvalWorkflows, map[string]interface{}{
			"key":   key,
			"steps": stepList,
		})
	}

	adjustmentSubtypesByType := utils.AdjustmentTransactionSubtypesByTypeForFrontend()

	return map[string]interface{}{
		"flags":               flagList,
		"legacy_flag_aliases": legacyFlagAliases,
		"product_flag_mapping": map[string]interface{}{
			"flags":            productMainFlags,
			"options":          productFlagOptions,
			"sub_flag_to_flag": productSubFlagToFlag,
		},
		"warehouse_types": []string{
			"AREA",
			"LOKASI",
			"KANDANG",
		},
		"stock_log": map[string][]string{
			"log_types":         []string{"TRANSFER", "ADJUSTMENT", "MARKETING", "CHICKIN", "PURCHASE", "RECORDING"},
			"transaction_types": []string{"INCREASE", "DECREASE"},
		},
		"supplier_categories": []string{
			"BOP",
			"SAPRONAK",
		},
		"customer_supplier_types": []string{
			"BISNIS",
			"INDIVIDUAL",
		},
		"adjustment": map[string]interface{}{
			"transaction_subtypes": adjustmentSubtypesByType,
		},
		"approval_workflows": approvalWorkflows,
	}, nil
}