package handlers

import (
	"encoding/json"
	"errors"
	"fmt"
	"net/http"
	"strconv"
	"strings"

	"github.com/lib/pq"
	"github.com/rede5/gohorsejobs/backend/internal/api/middleware"
	"github.com/rede5/gohorsejobs/backend/internal/dto"
	"github.com/rede5/gohorsejobs/backend/internal/models"
)

// JobServiceInterface describes the service needed by JobHandler
type JobServiceInterface interface {
	GetJobs(filter dto.JobFilterQuery) ([]models.JobWithCompany, int, error)
	CreateJob(req dto.CreateJobRequest, createdBy string) (*models.Job, error)
	GetJobByID(id string) (*models.Job, error)
	UpdateJob(id string, req dto.UpdateJobRequest) (*models.Job, error)
	DeleteJob(id string) error
}

type JobHandler struct {
	Service JobServiceInterface
}

func NewJobHandler(service JobServiceInterface) *JobHandler {
	return &JobHandler{Service: service}
}

// GetJobs godoc
// @Summary      List all jobs
// @Description  Get a paginated list of job postings with optional filters
// @Tags         Jobs
// @Accept       json
// @Produce      json
// @Param        page          query    int      false  "Page number (default: 1)"
// @Param        limit         query    int      false  "Items per page (default: 10, max: 100)"
// @Param        companyId     query    string   false  "Filter by company ID"
// @Param        featured      query    bool     false  "Filter by featured status"
// @Param        search        query    string   false  "Full-text search query"
// @Param        s             query    string   false  "Search query (Careerjet-style)"
// @Param        employmentType query   string   false  "Filter by employment type"
// @Param        workMode      query    string   false  "Filter by work mode (onsite, hybrid, remote)"
// @Param        location      query    string   false  "Filter by location text"
// @Param        l             query    string   false  "Location (Careerjet-style)"
// @Param        salaryMin     query    number   false  "Minimum salary filter"
// @Param        salaryMax     query    number   false  "Maximum salary filter"
// @Param        datePosted    query    string   false  "Date posted filter (24h, 7d, 30d)"
// @Param        sortBy        query    string   false  "Sort by: date, salary, relevance"
// @Param        sortOrder     query    string   false  "Sort order: asc, desc"
// @Success      200  {object}  dto.PaginatedResponse
// @Failure      500  {string}  string  "Internal Server Error"
// @Router       /api/v1/jobs [get]
func (h *JobHandler) GetJobs(w http.ResponseWriter, r *http.Request) {
	page, _ := strconv.Atoi(r.URL.Query().Get("page"))
	limit, _ := strconv.Atoi(r.URL.Query().Get("limit"))
	companyID := r.URL.Query().Get("companyId")
	isFeaturedStr := r.URL.Query().Get("featured")

	// Legacy and New Filter Handling
	search := r.URL.Query().Get("search")
	if search == "" {
		search = r.URL.Query().Get("q")
	}
	if search == "" {
		search = r.URL.Query().Get("s") // Careerjet-style alias (What)
	}

	employmentType := r.URL.Query().Get("employmentType")
	if employmentType == "" {
		employmentType = r.URL.Query().Get("type")
	}

	workMode := r.URL.Query().Get("workMode")
	location := r.URL.Query().Get("location")
	if location == "" {
		location = r.URL.Query().Get("l") // Careerjet-style alias (Where)
	}
	salaryMinStr := r.URL.Query().Get("salaryMin")
	salaryMaxStr := r.URL.Query().Get("salaryMax")
	sortBy := r.URL.Query().Get("sortBy")
	sortOrder := r.URL.Query().Get("sortOrder")

	// Date Posted filter (Careerjet-style: 24h, 7d, 30d)
	datePosted := r.URL.Query().Get("datePosted")
	if datePosted == "" {
		datePosted = r.URL.Query().Get("date") // Alternative alias
	}

	filter := dto.JobFilterQuery{
		PaginationQuery: dto.PaginationQuery{
			Page:  page,
			Limit: limit,
		},
		SortBy:    &sortBy,
		SortOrder: &sortOrder,
	}

	if companyID != "" {
		filter.CompanyID = &companyID
	}
	if isFeaturedStr == "true" {
		val := true
		filter.IsFeatured = &val
	}
	if search != "" {
		filter.Search = &search
	}
	if employmentType != "" {
		filter.EmploymentType = &employmentType
	}
	if workMode != "" {
		filter.WorkMode = &workMode
	}
	if location != "" {
		filter.Location = &location
		filter.LocationSearch = &location // Map to both for compatibility
	}
	if salaryMinStr != "" {
		if val, err := strconv.ParseFloat(salaryMinStr, 64); err == nil {
			filter.SalaryMin = &val
		}
	}
	if salaryMaxStr != "" {
		if val, err := strconv.ParseFloat(salaryMaxStr, 64); err == nil {
			filter.SalaryMax = &val
		}
	}
	if datePosted != "" {
		filter.DatePosted = &datePosted
	}

	jobs, total, err := h.Service.GetJobs(filter)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}

	if page == 0 {
		page = 1
	}
	if limit == 0 {
		limit = 10
	}

	response := dto.PaginatedResponse{
		Data: jobs,
		Pagination: dto.Pagination{
			Page:  page,
			Limit: limit,
			Total: total,
		},
	}

	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(response)
}

// CreateJob godoc
// @Summary      Create a new job
// @Description  Create a new job posting
// @Tags         Jobs
// @Accept       json
// @Produce      json
// @Param        job  body      dto.CreateJobRequest  true  "Job data"
// @Success      201  {object}  models.Job
// @Failure      400  {string}  string  "Bad Request"
// @Failure      401  {string}  string  "Unauthorized"
// @Failure      500  {string}  string  "Internal Server Error"
// @Router       /api/v1/jobs [post]
func (h *JobHandler) CreateJob(w http.ResponseWriter, r *http.Request) {
	fmt.Println("[CREATE_JOB DEBUG] === CreateJob Handler Started ===")

	var req dto.CreateJobRequest
	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
		fmt.Printf("[CREATE_JOB ERROR] Failed to decode request body: %v\n", err)
		http.Error(w, err.Error(), http.StatusBadRequest)
		return
	}

	if err := validateCreateJobRequest(&req); err != nil {
		http.Error(w, err.Error(), http.StatusBadRequest)
		return
	}

	fmt.Printf("[CREATE_JOB DEBUG] Request received: title=%s, companyId=%s, status=%s\n", req.Title, req.CompanyID, req.Status)
	fmt.Printf("[CREATE_JOB DEBUG] Full request: %+v\n", req)

	// Extract UserID from context
	val := r.Context().Value(middleware.ContextUserID)
	fmt.Printf("[CREATE_JOB DEBUG] Context UserID value: %v (type: %T)\n", val, val)

	userID, ok := val.(string)
	if !ok || userID == "" {
		fmt.Printf("[CREATE_JOB ERROR] UserID extraction failed. ok=%v, userID='%s'\n", ok, userID)
		http.Error(w, "Unauthorized: User ID missing", http.StatusUnauthorized)
		return
	}

	fmt.Printf("[CREATE_JOB DEBUG] UserID extracted: %s\n", userID)
	fmt.Println("[CREATE_JOB DEBUG] Calling service.CreateJob...")

	job, err := h.Service.CreateJob(req, userID)
	if err != nil {
		fmt.Printf("[CREATE_JOB ERROR] Service.CreateJob failed: %v\n", err)
		var pqErr *pq.Error
		if errors.As(err, &pqErr) {
			switch pqErr.Code {
			case "23514": // check_violation
				http.Error(w, fmt.Sprintf("invalid value: %s", pqErr.Constraint), http.StatusBadRequest)
			case "23503": // foreign_key_violation
				http.Error(w, "referenced resource not found", http.StatusBadRequest)
			case "23505": // unique_violation
				http.Error(w, "duplicate entry", http.StatusConflict)
			default:
				http.Error(w, "internal server error", http.StatusInternalServerError)
			}
			return
		}
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}

	fmt.Printf("[CREATE_JOB DEBUG] Job created successfully! ID=%s\n", job.ID)

	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(http.StatusCreated)
	json.NewEncoder(w).Encode(job)
}

// GetJobByID godoc
// @Summary      Get job by ID
// @Description  Get a single job posting by its ID
// @Tags         Jobs
// @Accept       json
// @Produce      json
// @Param        id   path      string  true  "Job ID"
// @Success      200  {object}  models.Job
// @Failure      400  {string}  string  "Bad Request"
// @Failure      404  {string}  string  "Not Found"
// @Router       /api/v1/jobs/{id} [get]
func (h *JobHandler) GetJobByID(w http.ResponseWriter, r *http.Request) {
	id := r.PathValue("id")

	job, err := h.Service.GetJobByID(id)
	if err != nil {
		http.Error(w, err.Error(), http.StatusNotFound)
		return
	}

	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(job)
}

// UpdateJob godoc
// @Summary      Update a job
// @Description  Update an existing job posting
// @Tags         Jobs
// @Accept       json
// @Produce      json
// @Param        id   path      string                   true  "Job ID"
// @Param        job  body      dto.UpdateJobRequest  true  "Updated job data"
// @Success      200  {object}  models.Job
// @Failure      400  {string}  string  "Bad Request"
// @Failure      500  {string}  string  "Internal Server Error"
// @Router       /api/v1/jobs/{id} [put]
func (h *JobHandler) UpdateJob(w http.ResponseWriter, r *http.Request) {
	id := r.PathValue("id")

	var req dto.UpdateJobRequest
	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
		http.Error(w, err.Error(), http.StatusBadRequest)
		return
	}

	job, err := h.Service.UpdateJob(id, req)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}

	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(job)
}

// DeleteJob godoc
// @Summary      Delete a job
// @Description  Delete a job posting
// @Tags         Jobs
// @Accept       json
// @Produce      json
// @Param        id   path      string  true  "Job ID"
// @Success      204  "No Content"
// @Failure      400  {string}  string  "Bad Request"
// @Failure      500  {string}  string  "Internal Server Error"
// @Router       /api/v1/jobs/{id} [delete]
func (h *JobHandler) DeleteJob(w http.ResponseWriter, r *http.Request) {
	id := r.PathValue("id")

	if err := h.Service.DeleteJob(id); err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}

	w.WriteHeader(http.StatusNoContent)
}

var validEmploymentTypes = map[string]bool{
	"full-time": true, "part-time": true, "dispatch": true, "contract": true,
	"temporary": true, "training": true, "voluntary": true, "permanent": true,
}

var validWorkModes = map[string]bool{
	"onsite": true, "hybrid": true, "remote": true,
}

var validJobStatuses = map[string]bool{
	"draft": true, "open": true, "closed": true, "review": true,
	"published": true, "paused": true, "expired": true, "archived": true, "reported": true,
}

func validateCreateJobRequest(req *dto.CreateJobRequest) error {
	if strings.TrimSpace(req.CompanyID) == "" {
		return fmt.Errorf("companyId is required")
	}
	title := strings.TrimSpace(req.Title)
	if title == "" {
		return fmt.Errorf("title is required")
	}
	if len(title) < 5 || len(title) > 255 {
		return fmt.Errorf("title must be between 5 and 255 characters")
	}
	if len(strings.TrimSpace(req.Description)) < 20 {
		return fmt.Errorf("description must be at least 20 characters")
	}
	if req.EmploymentType != nil && !validEmploymentTypes[*req.EmploymentType] {
		return fmt.Errorf("invalid employmentType %q, must be one of: full-time, part-time, dispatch, contract, temporary, training, voluntary, permanent", *req.EmploymentType)
	}
	if req.WorkMode != nil && !validWorkModes[*req.WorkMode] {
		return fmt.Errorf("invalid workMode %q, must be one of: onsite, hybrid, remote", *req.WorkMode)
	}
	if req.Status != "" && !validJobStatuses[req.Status] {
		return fmt.Errorf("invalid status %q", req.Status)
	}
	return nil
}