package handler

import (
	"lune/talentscale/internal/domain"
	"lune/talentscale/pkg/response"

	"github.com/gofiber/fiber/v2"
	"github.com/google/uuid"
)

type PackageHandler struct {
	usecase domain.PackageUsecase
}

func NewPackageHandler(usecase domain.PackageUsecase) *PackageHandler {
	return &PackageHandler{usecase: usecase}
}

type PackageRequest struct {
	Name                  string  `json:"name"`
	Description           string  `json:"description"`
	Price                 float64 `json:"price"`
	BillingCycle          string  `json:"billing_cycle"`
	OrderNumber           int     `json:"order_number"`
	MaxCandidatesPerMonth int     `json:"max_candidates_per_month"`
	MaxUsers              int     `json:"max_users"`
	HighlightPackage      bool    `json:"highlight_package"`
	BadgeLabel            string  `json:"badge_label"`
	ButtonText            string  `json:"button_text"`
	ButtonVariant         string  `json:"button_variant"`
	
	IsFeatureAllTests         bool `json:"is_feature_all_tests"`
	IsFeaturePdfReport        bool `json:"is_feature_pdf_report"`
	IsFeatureDashboard        bool `json:"is_feature_dashboard"`
	IsFeaturePrioritySupport  bool `json:"is_feature_priority_support"`
	IsFeatureApiAccess        bool `json:"is_feature_api_access"`
	IsFeatureCustomBranding   bool `json:"is_feature_custom_branding"`
	IsFeatureMultiUser        bool `json:"is_feature_multi_user"`
	IsFeatureExportExcel      bool `json:"is_feature_export_excel"`
	IsFeatureCandidateHistory bool `json:"is_feature_candidate_history"`
	IsFeatureAiInsight        bool `json:"is_feature_ai_insight"`

	ThemeColor string `json:"theme_color"`
}

// Create - POST /api/v1/packages
func (h *PackageHandler) Create(c *fiber.Ctx) error {
	var req PackageRequest
	if err := c.BodyParser(&req); err != nil {
		return response.BadRequest(c, "Invalid request body: "+err.Error())
	}
	
	pkg := &domain.Package{
		ID:                        uuid.New(),
		Name:                      req.Name,
		Description:               req.Description,
		Price:                     req.Price,
		BillingCycle:              req.BillingCycle,
		OrderNumber:               req.OrderNumber,
		MaxCandidatesPerMonth:     req.MaxCandidatesPerMonth,
		MaxUsers:                  req.MaxUsers,
		HighlightPackage:          req.HighlightPackage,
		BadgeLabel:                req.BadgeLabel,
		ButtonText:                req.ButtonText,
		ButtonVariant:             req.ButtonVariant,
		IsFeatureAllTests:         req.IsFeatureAllTests,
		IsFeaturePdfReport:        req.IsFeaturePdfReport,
		IsFeatureDashboard:        req.IsFeatureDashboard,
		IsFeaturePrioritySupport:  req.IsFeaturePrioritySupport,
		IsFeatureApiAccess:        req.IsFeatureApiAccess,
		IsFeatureCustomBranding:   req.IsFeatureCustomBranding,
		IsFeatureMultiUser:        req.IsFeatureMultiUser,
		IsFeatureExportExcel:      req.IsFeatureExportExcel,
		IsFeatureCandidateHistory: req.IsFeatureCandidateHistory,
		IsFeatureAiInsight:        req.IsFeatureAiInsight,
		ThemeColor:                req.ThemeColor,
	}
	
	if err := h.usecase.CreatePackage(c.Context(), pkg); err != nil {
		return response.InternalError(c, err.Error())
	}
	return response.Created(c, "Package created successfully", pkg)
}

// List - GET /api/v1/packages
func (h *PackageHandler) List(c *fiber.Ctx) error {
	packages, err := h.usecase.GetAllPackages(c.Context())
	if err != nil {
		return response.InternalError(c, err.Error())
	}
	return response.OK(c, "Packages retrieved successfully", packages)
}

// ListActive - GET /api/v1/public/packages
func (h *PackageHandler) ListActive(c *fiber.Ctx) error {
	packages, err := h.usecase.GetAllPackages(c.Context())
	if err != nil {
		return response.InternalError(c, err.Error())
	}

	type PackageResponse struct {
		domain.Package
		Features []string `json:"features"`
	}

	var resp []PackageResponse
	for _, p := range packages {
		var features []string
		if p.IsFeatureAllTests {
			features = append(features, "All Psychotests")
		}
		if p.IsFeaturePdfReport {
			features = append(features, "PDF Reports")
		}
		if p.IsFeatureDashboard {
			features = append(features, "Dashboard Analytics")
		}
		if p.IsFeaturePrioritySupport {
			features = append(features, "Priority Support")
		}
		if p.IsFeatureApiAccess {
			features = append(features, "API Access")
		}
		if p.IsFeatureCustomBranding {
			features = append(features, "Custom Branding")
		}
		if p.IsFeatureMultiUser {
			features = append(features, "Multi User Access")
		}
		if p.IsFeatureExportExcel {
			features = append(features, "Excel Export")
		}
		if p.IsFeatureCandidateHistory {
			features = append(features, "Candidate History")
		}
		if p.IsFeatureAiInsight {
			features = append(features, "AI Insight")
		}

		resp = append(resp, PackageResponse{
			Package:  p,
			Features: features,
		})
	}

	return response.OK(c, "Packages retrieved successfully", resp)
}

// GetByID - GET /api/v1/packages/:id
func (h *PackageHandler) GetByID(c *fiber.Ctx) error {
	id, err := uuid.Parse(c.Params("id"))
	if err != nil {
		return response.BadRequest(c, "Invalid package ID format")
	}
	pkg, err := h.usecase.GetPackageByID(c.Context(), id)
	if err != nil {
		return response.NotFound(c, err.Error())
	}
	return response.OK(c, "Package retrieved successfully", pkg)
}

// Update - PUT /api/v1/packages/:id
func (h *PackageHandler) Update(c *fiber.Ctx) error {
	id, err := uuid.Parse(c.Params("id"))
	if err != nil {
		return response.BadRequest(c, "Invalid package ID format")
	}
	var req PackageRequest
	if err := c.BodyParser(&req); err != nil {
		return response.BadRequest(c, "Invalid request body: "+err.Error())
	}
	pkg := &domain.Package{
		Name:                      req.Name,
		Description:               req.Description,
		Price:                     req.Price,
		BillingCycle:              req.BillingCycle,
		OrderNumber:               req.OrderNumber,
		MaxCandidatesPerMonth:     req.MaxCandidatesPerMonth,
		MaxUsers:                  req.MaxUsers,
		HighlightPackage:          req.HighlightPackage,
		BadgeLabel:                req.BadgeLabel,
		ButtonText:                req.ButtonText,
		ButtonVariant:             req.ButtonVariant,
		IsFeatureAllTests:         req.IsFeatureAllTests,
		IsFeaturePdfReport:        req.IsFeaturePdfReport,
		IsFeatureDashboard:        req.IsFeatureDashboard,
		IsFeaturePrioritySupport:  req.IsFeaturePrioritySupport,
		IsFeatureApiAccess:        req.IsFeatureApiAccess,
		IsFeatureCustomBranding:   req.IsFeatureCustomBranding,
		IsFeatureMultiUser:        req.IsFeatureMultiUser,
		IsFeatureExportExcel:      req.IsFeatureExportExcel,
		IsFeatureCandidateHistory: req.IsFeatureCandidateHistory,
		IsFeatureAiInsight:        req.IsFeatureAiInsight,
		ThemeColor:                req.ThemeColor,
	}
	if err := h.usecase.UpdatePackage(c.Context(), id, pkg); err != nil {
		return response.NotFound(c, err.Error())
	}
	return response.OK(c, "Package updated successfully", pkg)
}

// Delete - DELETE /api/v1/packages/:id
func (h *PackageHandler) Delete(c *fiber.Ctx) error {
	id, err := uuid.Parse(c.Params("id"))
	if err != nil {
		return response.BadRequest(c, "Invalid package ID format")
	}
	if err := h.usecase.DeletePackage(c.Context(), id); err != nil {
		return response.NotFound(c, err.Error())
	}
	return response.OK(c, "Package deleted successfully", nil)
}