package handler

import (
	"errors"
	"strconv"

	"accounting-app/pkg/api"
	"accounting-app/internal/service"

	"github.com/gin-gonic/gin"
)

// LedgerHandler handles HTTP requests for ledger operations
// Feature: accounting-feature-upgrade
// Validates: Requirements 3.1-3.6, 3.12
type LedgerHandler struct {
	ledgerService service.LedgerServiceInterface
}

// NewLedgerHandler creates a new LedgerHandler instance
func NewLedgerHandler(ledgerService service.LedgerServiceInterface) *LedgerHandler {
	return &LedgerHandler{
		ledgerService: ledgerService,
	}
}

// CreateLedger handles POST /api/v1/ledgers
// Creates a new ledger with the provided data
// Feature: accounting-feature-upgrade
// Validates: Requirements 3.1-3.6, 3.12
func (h *LedgerHandler) CreateLedger(c *gin.Context) {
	userId, exists := c.Get("user_id")
	if !exists {
		api.Unauthorized(c, "User not authenticated")
		return
	}

	var input service.LedgerInput
	if err := c.ShouldBindJSON(&input); err != nil {
		api.ValidationError(c, "Invalid request body: "+err.Error())
		return
	}

	ledger, err := h.ledgerService.CreateLedger(userId.(uint), input)
	if err != nil {
		if errors.Is(err, service.ErrLedgerLimitExceeded) {
			api.BadRequest(c, "Maximum 10 ledgers allowed")
			return
		}
		if errors.Is(err, service.ErrInvalidTheme) {
			api.BadRequest(c, "Invalid theme, must be one of: pink, beige, brown")
			return
		}
		api.InternalError(c, "Failed to create ledger: "+err.Error())
		return
	}

	api.Created(c, ledger)
}

// GetLedgers handles GET /api/v1/ledgers
// Returns a list of all ledgers
// Feature: accounting-feature-upgrade
// Validates: Requirements 3.2
func (h *LedgerHandler) GetLedgers(c *gin.Context) {
	userId, exists := c.Get("user_id")
	if !exists {
		api.Unauthorized(c, "User not authenticated")
		return
	}

	ledgers, err := h.ledgerService.GetAllLedgers(userId.(uint))
	if err != nil {
		api.InternalError(c, "Failed to get ledgers: "+err.Error())
		return
	}

	api.Success(c, ledgers)
}

// GetLedger handles GET /api/v1/ledgers/:id
// Returns a single ledger by ID
// Feature: accounting-feature-upgrade
// Validates: Requirements 3.2
func (h *LedgerHandler) GetLedger(c *gin.Context) {
	userId, exists := c.Get("user_id")
	if !exists {
		api.Unauthorized(c, "User not authenticated")
		return
	}

	id, err := strconv.ParseUint(c.Param("id"), 10, 32)
	if err != nil {
		api.BadRequest(c, "Invalid ledger ID")
		return
	}

	ledger, err := h.ledgerService.GetLedger(userId.(uint), uint(id))
	if err != nil {
		if errors.Is(err, service.ErrLedgerNotFound) {
			api.NotFound(c, "Ledger not found")
			return
		}
		api.InternalError(c, "Failed to get ledger: "+err.Error())
		return
	}

	api.Success(c, ledger)
}

// UpdateLedger handles PUT /api/v1/ledgers/:id
// Updates an existing ledger with the provided data
// Feature: accounting-feature-upgrade
// Validates: Requirements 3.6
func (h *LedgerHandler) UpdateLedger(c *gin.Context) {
	userId, exists := c.Get("user_id")
	if !exists {
		api.Unauthorized(c, "User not authenticated")
		return
	}

	id, err := strconv.ParseUint(c.Param("id"), 10, 32)
	if err != nil {
		api.BadRequest(c, "Invalid ledger ID")
		return
	}

	var input service.LedgerInput
	if err := c.ShouldBindJSON(&input); err != nil {
		api.ValidationError(c, "Invalid request body: "+err.Error())
		return
	}

	ledger, err := h.ledgerService.UpdateLedger(userId.(uint), uint(id), input)
	if err != nil {
		if errors.Is(err, service.ErrLedgerNotFound) {
			api.NotFound(c, "Ledger not found")
			return
		}
		if errors.Is(err, service.ErrInvalidTheme) {
			api.BadRequest(c, "Invalid theme, must be one of: pink, beige, brown")
			return
		}
		api.InternalError(c, "Failed to update ledger: "+err.Error())
		return
	}

	api.Success(c, ledger)
}

// DeleteLedger handles DELETE /api/v1/ledgers/:id
// Soft-deletes a ledger by ID
// Feature: accounting-feature-upgrade
// Validates: Requirements 3.7, 3.8, 3.15
func (h *LedgerHandler) DeleteLedger(c *gin.Context) {
	userId, exists := c.Get("user_id")
	if !exists {
		api.Unauthorized(c, "User not authenticated")
		return
	}

	id, err := strconv.ParseUint(c.Param("id"), 10, 32)
	if err != nil {
		api.BadRequest(c, "Invalid ledger ID")
		return
	}

	err = h.ledgerService.DeleteLedger(userId.(uint), uint(id))
	if err != nil {
		if errors.Is(err, service.ErrLedgerNotFound) {
			api.NotFound(c, "Ledger not found")
			return
		}
		if errors.Is(err, service.ErrCannotDeleteLastLedger) {
			api.BadRequest(c, "Cannot delete the last ledger")
			return
		}
		api.InternalError(c, "Failed to delete ledger: "+err.Error())
		return
	}

	api.NoContent(c)
}

// GetDeletedLedgers handles GET /api/v1/ledgers/deleted
// Returns a list of all soft-deleted ledgers
// Feature: accounting-feature-upgrade
// Validates: Requirements 3.9
func (h *LedgerHandler) GetDeletedLedgers(c *gin.Context) {
	userId, exists := c.Get("user_id")
	if !exists {
		api.Unauthorized(c, "User not authenticated")
		return
	}

	ledgers, err := h.ledgerService.GetDeletedLedgers(userId.(uint))
	if err != nil {
		api.InternalError(c, "Failed to get deleted ledgers: "+err.Error())
		return
	}

	api.Success(c, ledgers)
}

// RestoreLedger handles POST /api/v1/ledgers/:id/restore
// Restores a soft-deleted ledger by ID
// Feature: accounting-feature-upgrade
// Validates: Requirements 3.9
func (h *LedgerHandler) RestoreLedger(c *gin.Context) {
	userId, exists := c.Get("user_id")
	if !exists {
		api.Unauthorized(c, "User not authenticated")
		return
	}

	id, err := strconv.ParseUint(c.Param("id"), 10, 32)
	if err != nil {
		api.BadRequest(c, "Invalid ledger ID")
		return
	}

	err = h.ledgerService.RestoreLedger(userId.(uint), uint(id))
	if err != nil {
		if errors.Is(err, service.ErrLedgerNotFound) {
			api.NotFound(c, "Ledger not found")
			return
		}
		if errors.Is(err, service.ErrLedgerLimitExceeded) {
			api.BadRequest(c, "Maximum 10 ledgers allowed")
			return
		}
		api.InternalError(c, "Failed to restore ledger: "+err.Error())
		return
	}

	api.NoContent(c)
}

// RegisterRoutes registers all ledger routes to the given router group
func (h *LedgerHandler) RegisterRoutes(rg *gin.RouterGroup) {
	ledgers := rg.Group("/ledgers")
	{
		ledgers.POST("", h.CreateLedger)
		ledgers.GET("", h.GetLedgers)
		ledgers.GET("/deleted", h.GetDeletedLedgers)
		ledgers.GET("/:id", h.GetLedger)
		ledgers.PUT("/:id", h.UpdateLedger)
		ledgers.DELETE("/:id", h.DeleteLedger)
		ledgers.POST("/:id/restore", h.RestoreLedger)
	}
}