package tender

import (
	"errors"
	"mime"
	"net/http"
	"strconv"
	"time"
	"tm/pkg/logger"
	"tm/pkg/response"

	"github.com/asaskevich/govalidator"
	"github.com/labstack/echo/v4"
)

// TenderHandler handles tender-related HTTP requests
type TenderHandler struct {
	service Service
	logger  logger.Logger
}

// NewHandler creates a new tender handler
func NewHandler(service Service, logger logger.Logger) *TenderHandler {
	return &TenderHandler{
		service: service,
		logger:  logger,
	}
}

// *****************************************************
// *                      ADMIN HANDLERS                *
// *****************************************************

// GetTender retrieves a tender by ID
// @Summary Get tender by ID
// @Description Retrieve a specific tender by its ID
// @Tags Admin-Tenders
// @Produce json
// @Param id path string true "Tender ID"
// @Success 200 {object} response.APIResponse{data=TenderResponse}
// @Failure 404 {object} response.APIResponse
// @Failure 500 {object} response.APIResponse
// @Router /admin/v1/tenders/{id} [get]
// @Security BearerAuth
func (h *TenderHandler) Get(c echo.Context) error {
	id := c.Param("id")
	if id == "" {
		return response.BadRequest(c, "Tender ID is required", "ID parameter cannot be empty")
	}

	tender, err := h.service.GetByID(c.Request().Context(), id)
	if err != nil {
		return response.NotFound(c, "Tender not found")
	}

	return response.Success(c, tender, "Tender retrieved successfully")
}

// UpdateTender updates an existing tender
// @Summary Update tender
// @Description Update an existing tender with the provided information
// @Tags Admin-Tenders
// @Accept json
// @Produce json
// @Param id path string true "Tender ID"
// @Param tender body UpdateTenderRequest true "Updated tender information"
// @Success 200 {object} response.APIResponse{data=TenderResponse}
// @Failure 400 {object} response.APIResponse
// @Failure 404 {object} response.APIResponse
// @Failure 500 {object} response.APIResponse
// @Router /admin/v1/tenders/{id} [put]
// @Security BearerAuth
func (h *TenderHandler) Update(c echo.Context) error {
	id := c.Param("id")
	if id == "" {
		return response.BadRequest(c, "Tender ID is required", "ID parameter cannot be empty")
	}

	var req UpdateTenderRequest
	if err := c.Bind(&req); err != nil {
		return response.ValidationError(c, "Invalid request format", err.Error())
	}

	req.ID = id

	if _, err := govalidator.ValidateStruct(req); err != nil {
		return response.ValidationError(c, "Validation failed", err.Error())
	}

	tender, err := h.service.Update(c.Request().Context(), req)
	if err != nil {
		if err.Error() == "tender not found" {
			return response.NotFound(c, "Tender not found")
		}
		return response.InternalServerError(c, "Failed to update tender")
	}

	return response.Success(c, tender, "Tender updated successfully")
}

// DeleteTender deletes a tender
// @Summary Delete tender
// @Description Delete a tender by its ID
// @Tags Admin-Tenders
// @Param id path string true "Tender ID"
// @Success 200 {object} response.APIResponse
// @Failure 404 {object} response.APIResponse
// @Failure 500 {object} response.APIResponse
// @Router /admin/v1/tenders/{id} [delete]
// @Security BearerAuth
func (h *TenderHandler) Delete(c echo.Context) error {
	id := c.Param("id")
	if id == "" {
		return response.BadRequest(c, "Tender ID is required", "ID parameter cannot be empty")
	}

	err := h.service.Delete(c.Request().Context(), id)
	if err != nil {
		if err.Error() == "tender not found" {
			return response.NotFound(c, "Tender not found")
		}
		return response.InternalServerError(c, "Failed to delete tender")
	}

	return response.Success(c, map[string]interface{}{"deleted": true}, "Tender deleted successfully")
}

// ListTenders retrieves tenders with pagination and filtering
// @Summary List tenders
// @Description Retrieve tenders with pagination, filtering, and search capabilities with optional company-based matching
// @Tags Admin-Tenders
// @Produce json
// @Param company_id query string false "Company ID for match percentage calculation and sorting"
// @Param q query string false "Search query for title and description"
// @Param notice_type query string false "Filter by notice type code"
// @Param procurement_type query string false "Filter by procurement type code"
// @Param country_codes query []string false "Filter by country codes (comma-separated)"
// @Param status query []string false "Filter by status (comma-separated)"
// @Param source query []string false "Filter by source (comma-separated)"
// @Param min_estimated_value query number false "Minimum estimated value"
// @Param max_estimated_value query number false "Maximum estimated value"
// @Param currency query string false "Filter by currency"
// @Param deadline_from query number false "Deadline from"
// @Param deadline_to query number false "Deadline to"
// @Param publication_date_from query number false "Publication date from"
// @Param publication_date_to query number false "Publication date to"
// @Param languages query []string false "Filter by languages (comma-separated)"
// @Param buyer_organization_id query string false "Filter by buyer organization ID"
// @Param limit query int false "Number of items per page (default: 20, max: 100)"
// @Param offset query int false "Number of items to skip (default: 0)"
// @Param sort_by query string false "Sort by field"
// @Param sort_order query string false "Sort order (asc or desc)"
// @Success 200 {object} response.APIResponse{data=map[string]interface{}}
// @Failure 400 {object} response.APIResponse
// @Failure 500 {object} response.APIResponse
// @Router /admin/v1/tenders [get]
// @Security BearerAuth
func (h *TenderHandler) Search(c echo.Context) error {
	form, err := response.Parse[SearchForm](c)
	if err != nil {
		return response.ValidationError(c, "Invalid request data", err.Error())
	}

	// Validate form
	if _, err := govalidator.ValidateStruct(form); err != nil {
		return response.ValidationError(c, "Validation failed", err.Error())
	}

	// Call service
	tenders, err := h.service.Search(c.Request().Context(), form, response.NewPagination(c))
	if err != nil {
		return response.InternalServerError(c, "Failed to list tenders")
	}

	return response.SuccessWithMeta(c, tenders, tenders.Metadata, "Tenders retrieved successfully")
}

// *****************************************************
// *                   PUBLIC HANDLERS                 *
// *****************************************************

// GetPublicTenders retrieves public tenders for mobile app
// @Summary Get public tenders
// @Description Retrieve active tenders for mobile application users with automatic company-based matching from customer profile
// @Tags Tenders
// @Produce json
// @Param q query string false "Search query for title and description"
// @Param notice_type query string false "Filter by notice type code"
// @Param procurement_type query string false "Filter by procurement type code"
// @Param country_codes query []string false "Filter by country codes (comma-separated)"
// @Param status query []string false "Filter by status (comma-separated)"
// @Param source query []string false "Filter by source (comma-separated)"
// @Param min_estimated_value query number false "Minimum estimated value"
// @Param max_estimated_value query number false "Maximum estimated value"
// @Param currency query string false "Filter by currency"
// @Param deadline_from query number false "Deadline from"
// @Param deadline_to query number false "Deadline to"
// @Param publication_date_from query number false "Publication date from"
// @Param publication_date_to query number false "Publication date to"
// @Param languages query []string false "Filter by languages (comma-separated)"
// @Param buyer_organization_id query string false "Filter by buyer organization ID"
// @Param limit query int false "Number of items per page (default: 20, max: 100)"
// @Param offset query int false "Number of items to skip (default: 0)"
// @Param sort_by query string false "Sort by field"
// @Param sort_order query string false "Sort order (asc or desc)"
// @Success 200 {object} response.APIResponse{data=SearchResponse}
// @Failure 400 {object} response.APIResponse
// @Failure 500 {object} response.APIResponse
// @Security BearerAuth
// @Router /api/v1/tenders [get]
func (h *TenderHandler) GetPublicTenders(c echo.Context) error {

	form, err := response.Parse[SearchForm](c)
	if err != nil {
		return response.BadRequest(c, "Invalid request format", "")
	}

	if _, err := govalidator.ValidateStruct(form); err != nil {
		return response.ValidationError(c, err.Error(), "")
	}

	form.Status = []string{string(TenderStatusActive)}
	form.OnlyActiveDeadlines = true

	// Get company ID and customer ID from customer context for automatic matching
	var companyID *string
	if customerCompanyID, ok := c.Get("company_id").(string); ok {
		companyID = &customerCompanyID
	}
	form.CompanyID = companyID

	var customerID *string
	if customerIDStr, ok := c.Get("customer_id").(string); ok {
		customerID = &customerIDStr
	}
	form.CustomerID = customerID

	result, err := h.service.Search(c.Request().Context(), form, response.NewPagination(c))
	if err != nil {
		return response.InternalServerError(c, "Failed to retrieve tenders")
	}

	return response.SuccessWithMeta(c, result, result.Metadata, "Tenders retrieved successfully")
}

// GetPublicTenders retrieves public tenders for mobile app
// @Summary Get public tenders
// @Description Retrieve active tenders for mobile application users with automatic company-based matching from customer profile
// @Tags Tenders
// @Produce json
// @Param q query string false "Search query for title and description"
// @Param notice_type query string false "Filter by notice type code"
// @Param procurement_type query string false "Filter by procurement type code"
// @Param country_codes query []string false "Filter by country codes (comma-separated)"
// @Param status query []string false "Filter by status (comma-separated)"
// @Param source query []string false "Filter by source (comma-separated)"
// @Param min_estimated_value query number false "Minimum estimated value"
// @Param max_estimated_value query number false "Maximum estimated value"
// @Param currency query string false "Filter by currency"
// @Param deadline_from query number false "Deadline from"
// @Param deadline_to query number false "Deadline to"
// @Param publication_date_from query number false "Publication date from"
// @Param publication_date_to query number false "Publication date to"
// @Param languages query []string false "Filter by languages (comma-separated)"
// @Param buyer_organization_id query string false "Filter by buyer organization ID"
// @Param limit query int false "Number of items per page (default: 20, max: 100)"
// @Param offset query int false "Number of items to skip (default: 0)"
// @Param sort_by query string false "Sort by field"
// @Param sort_order query string false "Sort order (asc or desc)"
// @Success 200 {object} response.APIResponse{data=SearchResponse}
// @Failure 400 {object} response.APIResponse
// @Failure 500 {object} response.APIResponse
// @Security BearerAuth
// @Router /api/v1/tenders/recommend [get]
func (h *TenderHandler) RecommendTenders(c echo.Context) error {

	form, err := response.Parse[SearchForm](c)
	if err != nil {
		return response.BadRequest(c, "Invalid request format", "")
	}

	if _, err := govalidator.ValidateStruct(form); err != nil {
		return response.ValidationError(c, err.Error(), "")
	}

	form.Status = []string{string(TenderStatusActive)}
	form.OnlyActiveDeadlines = true

	var companyID *string
	if customerCompanyID, ok := c.Get("company_id").(string); ok {
		companyID = &customerCompanyID
	}
	form.CompanyID = companyID

	var customerID *string
	if customerIDStr, ok := c.Get("customer_id").(string); ok {
		customerID = &customerIDStr
	}
	form.CustomerID = customerID

	result, err := h.service.Recommend(c.Request().Context(), form, response.NewPagination(c))
	if err != nil {
		return response.InternalServerError(c, "Failed to retrieve tenders")
	}

	return response.SuccessWithMeta(c, result, result.Metadata, "Tenders retrieved successfully")
}

// GetPublicTenderDetails retrieves public tender details for mobile app
// @Summary Get public tender details
// @Description Retrieve detailed information about a specific tender for mobile application users
// @Tags Tenders
// @Produce json
// @Param id path string true "Tender ID"
// @Success 200 {object} response.APIResponse{data=map[string]interface{}}
// @Failure 404 {object} response.APIResponse
// @Failure 500 {object} response.APIResponse
// @Security BearerAuth
// @Router /api/v1/tenders/details/{id} [get]
func (h *TenderHandler) GetPublicTenderDetails(c echo.Context) error {
	id := c.Param("id")
	if id == "" {
		return response.BadRequest(c, "Tender ID is required", "ID parameter cannot be empty")
	}

	tender, err := h.service.GetByID(c.Request().Context(), id)
	if err != nil {
		return response.NotFound(c, "Tender not found")
	}

	// Only show tenders whose deadlines have not been reached
	if tender.TenderDeadline > 0 && tender.TenderDeadline <= time.Now().Unix() {
		return response.NotFound(c, "Tender not found")
	}

	return response.Success(c, tender, "Tender details retrieved successfully")
}

// GetDocumentSummaries retrieves document summaries for a tender
// @Summary Get document summaries for a tender
// @Description Retrieve AI-generated summaries of documents for a specific tender
// @Tags Tenders
// @Produce json
// @Param id path string true "Tender ID"
// @Success 200 {object} response.APIResponse{data=[]DocumentSummary}
// @Failure 400 {object} response.APIResponse
// @Failure 404 {object} response.APIResponse
// @Failure 500 {object} response.APIResponse
// @Router /api/v1/tenders/{id}/document-summaries [get]
func (h *TenderHandler) GetDocumentSummaries(c echo.Context) error {
	id := c.Param("id")
	if id == "" {
		return response.BadRequest(c, "Tender ID is required", "ID parameter cannot be empty")
	}

	summaries, err := h.service.GetDocumentSummaries(c.Request().Context(), id)
	if err != nil {
		h.logger.Error("Failed to get document summaries", map[string]interface{}{
			"tender_id": id,
			"error":     err.Error(),
		})
		return response.NotFound(c, "Document summaries not found")
	}

	return response.Success(c, summaries, "Document summaries retrieved successfully")
}

// GetDocuments retrieves scraped documents for a tender
// @Summary Get scraped documents for a tender
// @Description Retrieve scraped document metadata for a specific tender
// @Tags Tenders
// @Produce json
// @Param id path string true "Tender ID"
// @Success 200 {object} response.APIResponse{data=TenderDocumentsResponse}
// @Failure 400 {object} response.APIResponse
// @Failure 404 {object} response.APIResponse
// @Failure 500 {object} response.APIResponse
// @Router /api/v1/tenders/{id}/documents [get]
func (h *TenderHandler) GetDocuments(c echo.Context) error {
	id := c.Param("id")
	if id == "" {
		return response.BadRequest(c, "Tender ID is required", "ID parameter cannot be empty")
	}

	documents, err := h.service.GetDocuments(c.Request().Context(), id)
	if err != nil {
		return response.NotFound(c, "Tender documents not found")
	}

	return response.Success(c, documents, "Tender documents retrieved successfully")
}

// DownloadDocuments downloads all scraped documents for a tender
// @Summary Download scraped documents for a tender
// @Description Stream all scraped tender documents from storage as a ZIP archive
// @Tags Tenders
// @Produce application/zip
// @Param id path string true "Tender ID"
// @Success 200 {file} file
// @Failure 400 {object} response.APIResponse
// @Failure 404 {object} response.APIResponse
// @Failure 500 {object} response.APIResponse
// @Router /api/v1/tenders/{id}/documents/download [get]
func (h *TenderHandler) DownloadDocuments(c echo.Context) error {
	id := c.Param("id")
	if id == "" {
		return response.BadRequest(c, "Tender ID is required", "ID parameter cannot be empty")
	}

	download, err := h.service.DownloadDocuments(c.Request().Context(), id)
	if err != nil {
		if errors.Is(err, ErrTenderDocumentNotFound) {
			return response.NotFound(c, "Tender documents not found")
		}
		if errors.Is(err, ErrTenderDocumentStorageUnavailable) {
			return response.InternalServerError(c, "Tender document storage is unavailable")
		}
		return response.InternalServerError(c, "Failed to download tender documents")
	}
	defer download.Reader.Close()

	headers := c.Response().Header()
	headers.Set(echo.HeaderContentDisposition, mime.FormatMediaType("attachment", map[string]string{
		"filename": download.Filename,
	}))
	if download.Size > 0 {
		headers.Set(echo.HeaderContentLength, strconv.FormatInt(download.Size, 10))
	}

	return c.Stream(http.StatusOK, download.ContentType, download.Reader)
}

// GetAISummary retrieves the AI-generated overall summary for a tender
// @Summary Get AI-generated tender summary
// @Description Retrieve the AI-generated overall summary for a tender from the AI pipeline storage
// @Tags Admin-Tenders
// @Produce json
// @Param id path string true "Tender ID"
// @Success 200 {object} response.APIResponse{data=AISummaryResponse}
// @Failure 400 {object} response.APIResponse
// @Failure 404 {object} response.APIResponse
// @Failure 500 {object} response.APIResponse
// @Router /admin/v1/tenders/{id}/ai-summary [get]
// @Security BearerAuth
func (h *TenderHandler) GetAISummary(c echo.Context) error {
	id := c.Param("id")
	if id == "" {
		return response.BadRequest(c, "Tender ID is required", "ID parameter cannot be empty")
	}

	summary, err := h.service.GetAISummary(c.Request().Context(), id)
	if err != nil {
		h.logger.Error("Failed to get AI summary", map[string]interface{}{
			"tender_id": id,
			"error":     err.Error(),
		})
		return response.NotFound(c, err.Error())
	}

	return response.Success(c, summary, "AI summary retrieved successfully")
}

// TriggerAISummarize triggers on-demand AI summarization for a tender
// @Summary Trigger AI summarization
// @Description Trigger on-demand AI summarization for a tender by calling the external AI service
// @Tags Admin-Tenders
// @Produce json
// @Param id path string true "Tender ID"
// @Success 200 {object} response.APIResponse{data=AISummarizeResponse}
// @Failure 400 {object} response.APIResponse
// @Failure 404 {object} response.APIResponse
// @Failure 500 {object} response.APIResponse
// @Router /admin/v1/tenders/{id}/ai-summarize [post]
// @Security BearerAuth
func (h *TenderHandler) TriggerAISummarize(c echo.Context) error {
	id := c.Param("id")
	if id == "" {
		return response.BadRequest(c, "Tender ID is required", "ID parameter cannot be empty")
	}

	result, err := h.service.TriggerAISummarize(c.Request().Context(), id)
	if err != nil {
		h.logger.Error("Failed to trigger AI summarization", map[string]interface{}{
			"tender_id": id,
			"error":     err.Error(),
		})
		return response.InternalServerError(c, err.Error())
	}

	return response.Success(c, result, "AI summarization completed successfully")
}

// TriggerAITranslate triggers on-demand AI translation for a tender
// @Summary Trigger AI translation
// @Description Trigger on-demand AI translation for tender title and description and store it in MongoDB
// @Tags Admin-Tenders
// @Accept json
// @Produce json
// @Param id path string true "Tender ID"
// @Param request body AITranslateRequest false "Translation language request (defaults to en)"
// @Success 200 {object} response.APIResponse{data=AITranslateResponse}
// @Failure 400 {object} response.APIResponse
// @Failure 500 {object} response.APIResponse
// @Router /admin/v1/tenders/{id}/ai-translate [post]
// @Security BearerAuth
func (h *TenderHandler) TriggerAITranslate(c echo.Context) error {
	id := c.Param("id")
	if id == "" {
		return response.BadRequest(c, "Tender ID is required", "ID parameter cannot be empty")
	}

	req := AITranslateRequest{Language: "en"}
	_ = c.Bind(&req)
	if req.Language == "" {
		req.Language = "en"
	}

	if _, err := govalidator.ValidateStruct(req); err != nil {
		return response.ValidationError(c, "Validation failed", err.Error())
	}

	result, err := h.service.TriggerAITranslate(c.Request().Context(), id, req.Language)
	if err != nil {
		return response.InternalServerError(c, err.Error())
	}

	return response.Success(c, result, "AI translation completed successfully")
}

// GetPublicAISummary retrieves the AI-generated overall summary for a tender (public endpoint)
// @Summary Get AI-generated tender summary (public)
// @Description Retrieve the AI-generated overall summary for a tender from the AI pipeline storage
// @Tags Tenders
// @Produce json
// @Param id path string true "Tender ID"
// @Success 200 {object} response.APIResponse{data=AISummaryResponse}
// @Failure 400 {object} response.APIResponse
// @Failure 404 {object} response.APIResponse
// @Failure 500 {object} response.APIResponse
// @Router /api/v1/tenders/{id}/ai-summary [get]
// @Security BearerAuth
func (h *TenderHandler) GetPublicAISummary(c echo.Context) error {
	id := c.Param("id")
	if id == "" {
		return response.BadRequest(c, "Tender ID is required", "ID parameter cannot be empty")
	}

	summary, err := h.service.GetAISummary(c.Request().Context(), id)
	if err != nil {
		h.logger.Error("Failed to get AI summary", map[string]interface{}{
			"tender_id": id,
			"error":     err.Error(),
		})
		return response.NotFound(c, err.Error())
	}

	return response.Success(c, summary, "AI summary retrieved successfully")
}

// TriggerPublicAITranslate triggers on-demand AI translation for a tender (public endpoint)
// @Summary Trigger AI translation (public)
// @Description Trigger on-demand AI translation for tender title and description and store it in MongoDB
// @Tags Tenders
// @Accept json
// @Produce json
// @Param id path string true "Tender ID"
// @Param request body AITranslateRequest false "Translation language request (defaults to en)"
// @Success 200 {object} response.APIResponse{data=AITranslateResponse}
// @Failure 400 {object} response.APIResponse
// @Failure 500 {object} response.APIResponse
// @Router /api/v1/tenders/{id}/ai-translate [post]
// @Security BearerAuth
func (h *TenderHandler) TriggerPublicAITranslate(c echo.Context) error {
	id := c.Param("id")
	if id == "" {
		return response.BadRequest(c, "Tender ID is required", "ID parameter cannot be empty")
	}

	req := AITranslateRequest{Language: "en"}
	_ = c.Bind(&req)
	if req.Language == "" {
		req.Language = "en"
	}

	if _, err := govalidator.ValidateStruct(req); err != nil {
		return response.ValidationError(c, "Validation failed", err.Error())
	}

	result, err := h.service.TriggerAITranslate(c.Request().Context(), id, req.Language)
	if err != nil {
		return response.InternalServerError(c, err.Error())
	}

	return response.Success(c, result, "AI translation completed successfully")
}

// GetAllAISummaries retrieves all AI-generated summaries from storage
// @Summary Get all AI-generated tender summaries
// @Description Retrieve all AI-generated summaries from the AI pipeline storage, including pending and completed ones
// @Tags Admin-Tenders
// @Produce json
// @Success 200 {object} response.APIResponse{data=[]ai_summarizer.TenderSummaryItem}
// @Failure 500 {object} response.APIResponse
// @Router /admin/v1/tenders/ai-summaries [get]
// @Security BearerAuth
func (h *TenderHandler) GetAllAISummaries(c echo.Context) error {
	summaries, err := h.service.GetAllAISummaries(c.Request().Context())
	if err != nil {
		h.logger.Error("Failed to get all AI summaries", map[string]interface{}{
			"error": err.Error(),
		})
		return response.InternalServerError(c, err.Error())
	}

	return response.Success(c, summaries, "AI summaries retrieved successfully")
}