package utils

import (
	"strings"

	approvalutils "gitlab.com/mbugroup/lti-api.git/internal/utils/approvals"
)

// -------------------------------------------------------------------
// FlagType & Groups
// -------------------------------------------------------------------

type FlagType string

type FlagGroup string

const (
	FlagIsActive FlagType = "IS_ACTIVE"

	FlagDOC        FlagType = "DOC"
	FlagPullet     FlagType = "PULLET"
	FlagLayer      FlagType = "LAYER"
	FlagPakan      FlagType = "PAKAN"
	FlagPreStarter FlagType = "PRE-STARTER"
	FlagStarter    FlagType = "STARTER"
	FlagFinisher   FlagType = "FINISHER"
	FlagOVK        FlagType = "OVK"
	FlagObat       FlagType = "OBAT"
	FlagVitamin    FlagType = "VITAMIN"
	FlagKimia      FlagType = "KIMIA"
	FlagEkspedisi  FlagType = "EKSPEDISI"
)

const (
	FlagGroupProduct  FlagGroup = "PRODUCT"
	FlagGroupNonstock FlagGroup = "NONSTOCK"
)

var flagGroupOptions = map[FlagGroup][]FlagType{
	FlagGroupProduct: {
		FlagDOC,
		FlagPullet,
		FlagLayer,
		FlagPakan,
		FlagPreStarter,
		FlagStarter,
		FlagFinisher,
		FlagOVK,
		FlagObat,
		FlagVitamin,
		FlagKimia,
	},
	FlagGroupNonstock: {
		FlagEkspedisi,
	},
}

var allFlagTypes = func() map[FlagType]struct{} {
	m := map[FlagType]struct{}{
		FlagIsActive: {},
	}
	for _, flags := range flagGroupOptions {
		for _, flag := range flags {
			m[flag] = struct{}{}
		}
	}
	return m
}()

func AllFlagTypes() map[FlagType]struct{} {
	return allFlagTypes
}

// -------------------------------------------------------------------
// WarehouseType
// -------------------------------------------------------------------

type WarehouseType string

const (
	WarehouseTypeArea    WarehouseType = "AREA"
	WarehouseTypeLokasi  WarehouseType = "LOKASI"
	WarehouseTypeKandang WarehouseType = "KANDANG"
)

// -------------------------------------------------------------------
// Stock log
// -------------------------------------------------------------------

type StockLogTransactionType string

const (
	StockLogTransactionTypeIncrease StockLogTransactionType = "INCREASE"
	StockLogTransactionTypeDecrease StockLogTransactionType = "DECREASE"
)

type StockLogType string

const (
	StockLogTypeAdjustment StockLogType = "ADJUSTMENT"
	StockLogTypeTransfer   StockLogType = "TRANSFER"
)

// -------------------------------------------------------------------
// WarehouseType
// -------------------------------------------------------------------

type CustomerSupplierType string

const (
	CustomerSupplierTypeBisnis     CustomerSupplierType = "BISNIS"
	CustomerSupplierTypeIndividual CustomerSupplierType = "INDIVIDUAL"
)

// -------------------------------------------------------------------
// SupplierCategory
// -------------------------------------------------------------------

type SupplierCategory string

const (
	SupplierCategoryBOP      SupplierCategory = "BOP"
	SupplierCategorySapronak SupplierCategory = "SAPRONAK"
)

// -------------------------------------------------------------------
// Kandang Status
// -------------------------------------------------------------------

type KandangStatus string

const (
	KandangStatusNonActive KandangStatus = "NON_ACTIVE"
	KandangStatusPengajuan KandangStatus = "PENGAJUAN"
	KandangStatusActive    KandangStatus = "ACTIVE"
)

// -------------------------------------------------------------------
// ProjectFlockCategory
// -------------------------------------------------------------------

type ProjectFlockCategory string

const (
	ProjectFlockCategoryGrowing ProjectFlockCategory = "GROWING"
	ProjectFlockCategoryLaying  ProjectFlockCategory = "LAYING"
)

// -------------------------------------------------------------------
// Project Flock Approval
// -------------------------------------------------------------------

const (
	ApprovalWorkflowProjectFlock approvalutils.ApprovalWorkflowKey = approvalutils.ApprovalWorkflowKey("PROJECT_FLOCKS")
	ProjectFlockStepPengajuan    approvalutils.ApprovalStep        = 1
	ProjectFlockStepAktif        approvalutils.ApprovalStep        = 2
)

// projectFlockApprovalSteps keeps the workflow step definitions for project flock approvals.
var ProjectFlockApprovalSteps = map[approvalutils.ApprovalStep]string{
	ProjectFlockStepPengajuan: "Pengajuan",
	ProjectFlockStepAktif:     "Aktif",
}

// -------------------------------------------------------------------
// Chickin Approval
// -------------------------------------------------------------------
const (
	ApprovalWorkflowChickin approvalutils.ApprovalWorkflowKey = approvalutils.ApprovalWorkflowKey("CHICKINS")
	ChickinStepPengajuan    approvalutils.ApprovalStep        = 1
	ChickinStepDisetujui    approvalutils.ApprovalStep        = 2
)

var ChickinApprovalSteps = map[approvalutils.ApprovalStep]string{
	ChickinStepPengajuan: "Pengajuan",
	ChickinStepDisetujui: "Disetujui",
}

// -------------------------------------------------------------------
// Project-Flock kandang Approval
// -------------------------------------------------------------------
const (
	ApprovalWorkflowProjectFlockKandang approvalutils.ApprovalWorkflowKey = approvalutils.ApprovalWorkflowKey("PROJECT_FLOCK_KANDANGS")
	ProjectFlockKandangStepPengajuan    approvalutils.ApprovalStep        = 1
	ProjectFlockKandangStepDisetujui    approvalutils.ApprovalStep        = 2
	ProjectFlockKandangStepClosed       approvalutils.ApprovalStep        = 3
)

var ProjectFlockKandangApprovalSteps = map[approvalutils.ApprovalStep]string{
	ProjectFlockKandangStepPengajuan: "Pengajuan",
	ProjectFlockKandangStepDisetujui: "Disetujui",
	ProjectFlockKandangStepClosed:    "Closed",
}

// -------------------------------------------------------------------
// Transfer To laying Approval
// -------------------------------------------------------------------
const (
	ApprovalWorkflowTransferToLaying approvalutils.ApprovalWorkflowKey = approvalutils.ApprovalWorkflowKey("TRANSFER_TO_LAYINGS")
	TransferToLayingStepPengajuan    approvalutils.ApprovalStep        = 1
	TransferToLayingStepDisetujui    approvalutils.ApprovalStep        = 2
)

var TransferToLayingApprovalSteps = map[approvalutils.ApprovalStep]string{
	TransferToLayingStepPengajuan: "Pengajuan",
	TransferToLayingStepDisetujui: "Disetujui",
}

// -------------------------------------------------------------------

// -------------------------------------------------------------------
// Recording Approval
// -------------------------------------------------------------------

const (
	ApprovalWorkflowRecording approvalutils.ApprovalWorkflowKey = approvalutils.ApprovalWorkflowKey("RECORDINGS")
	RecordingStepGradingTelur approvalutils.ApprovalStep        = 1
	RecordingStepPengajuan    approvalutils.ApprovalStep        = 2
	RecordingStepDisetujui    approvalutils.ApprovalStep        = 3
)

var RecordingApprovalSteps = map[approvalutils.ApprovalStep]string{
	RecordingStepGradingTelur: "Grading-Telur",
	RecordingStepPengajuan:    "Pengajuan",
	RecordingStepDisetujui:    "Disetujui",
}

// -------------------------------------------------------------------
// Purchase Approval
// -------------------------------------------------------------------

const (
	ApprovalWorkflowPurchase  approvalutils.ApprovalWorkflowKey = approvalutils.ApprovalWorkflowKey("PURCHASES")
	PurchaseStepPengajuan     approvalutils.ApprovalStep        = 1
	PurchaseStepStaffPurchase approvalutils.ApprovalStep        = 2
	PurchaseStepManager       approvalutils.ApprovalStep        = 3
	PurchaseStepReceiving     approvalutils.ApprovalStep        = 4
	PurchaseStepCompleted     approvalutils.ApprovalStep        = 5

	PurchasePRNumberPrefix = "PR-LTI-"
	PurchasePONumberPrefix = "PO-LTI-"
	PurchaseNumberPadding  = 4
)

var PurchaseApprovalSteps = map[approvalutils.ApprovalStep]string{
	PurchaseStepPengajuan:     "Pengajuan",
	PurchaseStepStaffPurchase: "Staff Purchase",
	PurchaseStepManager:       "Manager Purchase",
	PurchaseStepReceiving:     "Penerimaan Produk",
	PurchaseStepCompleted:     "Selesai",
}

// -------------------------------------------------------------------
// Marketings Approval
// -------------------------------------------------------------------

const (
	ApprovalWorkflowMarketing approvalutils.ApprovalWorkflowKey = approvalutils.ApprovalWorkflowKey("MARKETINGS")
	MarketingStepPengajuan    approvalutils.ApprovalStep        = 1
	MarketingStepSalesOrder   approvalutils.ApprovalStep        = 2
	MarketingDeliveryOrder    approvalutils.ApprovalStep        = 3

	MarketingSoNumberPrefix = "SO-"
	MarketingNumberPadding  = 5
)

var MarketingApprovalSteps = map[approvalutils.ApprovalStep]string{
	MarketingStepPengajuan:  "Pengajuan",
	MarketingStepSalesOrder: "Sales Order",
	MarketingDeliveryOrder:  "Delivery Order",
}

// -------------------------------------------------------------------
// Expense Approval
// -------------------------------------------------------------------

const (
	ApprovalWorkflowExpense approvalutils.ApprovalWorkflowKey = approvalutils.ApprovalWorkflowKey("EXPENSES")
	ExpenseStepPengajuan    approvalutils.ApprovalStep        = 1
	ExpenseStepManager      approvalutils.ApprovalStep        = 2
	ExpenseStepFinance      approvalutils.ApprovalStep        = 3
	ExpenseStepRealisasi    approvalutils.ApprovalStep        = 4
	ExpenseStepSelesai      approvalutils.ApprovalStep        = 5
)

var ExpenseApprovalSteps = map[approvalutils.ApprovalStep]string{
	ExpenseStepPengajuan: "Pengajuan",
	ExpenseStepManager:   "Approval Manager",
	ExpenseStepFinance:   "Approval Finance",
	ExpenseStepRealisasi: "Realisasi",
	ExpenseStepSelesai:   "Selesai",
}

// -------------------------------------------------------------------
// Validators
// -------------------------------------------------------------------

func IsValidFlagType(v string) bool {
	_, ok := allFlagTypes[FlagType(strings.ToUpper(strings.TrimSpace(v)))]
	return ok
}

func AllowedFlagTypes(group FlagGroup) []FlagType {
	options, ok := flagGroupOptions[group]
	if !ok {
		return nil
	}
	result := make([]FlagType, len(options))
	copy(result, options)
	return result
}

func InvalidFlagsForGroup(flags []FlagType, group FlagGroup) []FlagType {
	if len(flags) == 0 {
		return nil
	}
	options, ok := flagGroupOptions[group]
	if !ok {
		return flags
	}
	allowed := make(map[FlagType]struct{}, len(options))
	for _, flag := range options {
		allowed[flag] = struct{}{}
	}
	invalid := make([]FlagType, 0)
	for _, flag := range flags {
		if _, ok := allowed[flag]; !ok {
			invalid = append(invalid, flag)
		}
	}
	return invalid
}

func NormalizeFlagTypes(flags []string) []FlagType {
	if len(flags) == 0 {
		return nil
	}
	seen := make(map[FlagType]struct{}, len(flags))
	result := make([]FlagType, 0, len(flags))
	for _, flag := range flags {
		normalized := FlagType(strings.ToUpper(strings.TrimSpace(flag)))
		if normalized == "" {
			continue
		}
		if _, exists := seen[normalized]; exists {
			continue
		}
		seen[normalized] = struct{}{}
		result = append(result, normalized)
	}
	if len(result) == 0 {
		return nil
	}
	return result
}

func FlagTypesToStrings(flags []FlagType) []string {
	if len(flags) == 0 {
		return nil
	}
	result := make([]string, len(flags))
	for i, flag := range flags {
		result[i] = string(flag)
	}
	return result
}

func NormalizeFlagsForGroup(raw []string, group FlagGroup) (normalized []FlagType, invalid []FlagType) {
	normalized = NormalizeFlagTypes(raw)
	if len(normalized) == 0 {
		return nil, nil
	}
	invalid = InvalidFlagsForGroup(normalized, group)
	if len(invalid) == 0 {
		return normalized, nil
	}
	return normalized, invalid
}

func IsValidWarehouseType(v string) bool {
	switch WarehouseType(v) {
	case WarehouseTypeArea, WarehouseTypeLokasi, WarehouseTypeKandang:
		return true
	}
	return false
}

func IsValidKandangStatus(v string) bool {
	switch KandangStatus(v) {
	case KandangStatusNonActive, KandangStatusPengajuan, KandangStatusActive:
		return true
	}
	return false
}

func IsValidCustomerSupplierType(v string) bool {
	switch CustomerSupplierType(v) {
	case CustomerSupplierTypeBisnis, CustomerSupplierTypeIndividual:
		return true
	}
	return false
}

func IsValidProjectFlockCategory(v string) bool {
	switch ProjectFlockCategory(v) {
	case ProjectFlockCategoryGrowing, ProjectFlockCategoryLaying:
		return true
	}
	return false
}

func IsValidSupplierCategory(v string) bool {
	switch SupplierCategory(v) {
	case SupplierCategoryBOP, SupplierCategorySapronak:
		return true
	}
	return false
}

// example use

// Recording helper

/**
if !utils.IsValidFlagType(req.FlagName) {
    return fiber.NewError(fiber.StatusBadRequest, "Invalid flag type")
}
*/