package handlers

import (
	dbgen "Yimaru-Backend/gen/db"
	"Yimaru-Backend/internal/domain"
	"bytes"
	"io"
	"net/http"
	"strconv"
	"strings"
	"time"

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

type uploadMediaRes struct {
	ObjectKey   string `json:"object_key"`
	URL         string `json:"url"`
	ContentType string `json:"content_type"`
	MediaType   string `json:"media_type"`
	Provider    string `json:"provider"`
	VimeoID     string `json:"vimeo_id,omitempty"`
	EmbedURL    string `json:"embed_url,omitempty"`
}

// resolveFileURL converts a stored file path to a usable URL.
// If the path starts with "minio://", it generates a presigned URL.
// Otherwise it returns the path as-is (e.g. "/static/...").
func (h *Handler) resolveFileURL(c *fiber.Ctx, storedPath string) string {
	if h.minioSvc == nil || !strings.HasPrefix(storedPath, "minio://") {
		return storedPath
	}
	objectKey := strings.TrimPrefix(storedPath, "minio://")
	url, err := h.minioSvc.GetURL(c.Context(), objectKey, 1*time.Hour)
	if err != nil {
		return storedPath
	}
	return url
}

// GetFileURL resolves a MinIO object key to a presigned download URL.
// @Summary Get presigned URL for a file
// @Tags files
// @Param key query string true "MinIO object key (e.g. profile_pictures/uuid.jpg)"
// @Success 200 {object} domain.Response
// @Router /api/v1/files/url [get]
func (h *Handler) GetFileURL(c *fiber.Ctx) error {
	key := strings.TrimSpace(c.Query("key"))
	if key == "" {
		return c.Status(fiber.StatusBadRequest).JSON(domain.ErrorResponse{
			Message: "Missing 'key' query parameter",
		})
	}

	if h.minioSvc == nil {
		return c.Status(fiber.StatusServiceUnavailable).JSON(domain.ErrorResponse{
			Message: "File storage service is not available",
		})
	}

	url, err := h.minioSvc.GetURL(c.Context(), key, 1*time.Hour)
	if err != nil {
		return c.Status(fiber.StatusInternalServerError).JSON(domain.ErrorResponse{
			Message: "Failed to generate file URL",
			Error:   err.Error(),
		})
	}

	return c.Status(fiber.StatusOK).JSON(domain.Response{
		Message:    "File URL generated",
		Data:       map[string]string{"url": url},
		Success:    true,
		StatusCode: fiber.StatusOK,
	})
}

// UploadMedia uploads an image/audio/video file and returns its URL and key.
// @Summary Upload media file
// @Tags files
// @Accept multipart/form-data
// @Param media_type formData string true "Media type: image|audio|video"
// @Param file formData file true "Media file"
// @Success 200 {object} domain.Response
// @Router /api/v1/files/upload [post]
func (h *Handler) UploadMedia(c *fiber.Ctx) error {
	mediaType := strings.ToLower(strings.TrimSpace(c.FormValue("media_type")))
	if mediaType == "" {
		mediaType = "file"
	}
	if mediaType != "image" && mediaType != "audio" && mediaType != "video" {
		return c.Status(fiber.StatusBadRequest).JSON(domain.ErrorResponse{
			Message: "Invalid media_type",
			Error:   "media_type must be one of: image, audio, video",
		})
	}

	fileHeader, err := c.FormFile("file")
	if err != nil {
		return c.Status(fiber.StatusBadRequest).JSON(domain.ErrorResponse{
			Message: "File is required",
			Error:   err.Error(),
		})
	}

	maxSize := int64(100 * 1024 * 1024) // default 100MB
	switch mediaType {
	case "image":
		maxSize = 10 * 1024 * 1024
	case "audio":
		maxSize = 50 * 1024 * 1024
	case "video":
		maxSize = 500 * 1024 * 1024
	}
	if fileHeader.Size > maxSize {
		return c.Status(fiber.StatusBadRequest).JSON(domain.ErrorResponse{
			Message: "File too large",
			Error:   "File exceeds size limit for selected media_type",
		})
	}

	if mediaType == "video" && h.vimeoSvc == nil {
		return c.Status(fiber.StatusServiceUnavailable).JSON(domain.ErrorResponse{
			Message: "Vimeo service is not available for video uploads",
		})
	}
	if (mediaType == "image" || mediaType == "audio") && h.minioSvc == nil {
		return c.Status(fiber.StatusServiceUnavailable).JSON(domain.ErrorResponse{
			Message: "MinIO service is not available for image/audio uploads",
		})
	}

	fh, err := fileHeader.Open()
	if err != nil {
		return c.Status(fiber.StatusInternalServerError).JSON(domain.ErrorResponse{
			Message: "Failed to read file",
			Error:   err.Error(),
		})
	}
	defer fh.Close()

	head := make([]byte, 512)
	n, _ := fh.Read(head)
	contentType := http.DetectContentType(head[:n])

	switch mediaType {
	case "image":
		if contentType != "image/jpeg" && contentType != "image/png" && contentType != "image/webp" {
			return c.Status(fiber.StatusBadRequest).JSON(domain.ErrorResponse{
				Message: "Invalid file type",
				Error:   "Only jpg, png, and webp images are allowed",
			})
		}
	case "audio":
		allowedAudio := map[string]bool{
			"audio/mpeg": true, "audio/wav": true, "audio/ogg": true, "audio/mp4": true,
			"audio/aac": true, "audio/webm": true, "video/ogg": true, "video/webm": true,
			"audio/x-wav": true, "audio/x-m4a": true, "audio/flac": true,
		}
		if !allowedAudio[contentType] {
			return c.Status(fiber.StatusBadRequest).JSON(domain.ErrorResponse{
				Message: "Invalid file type",
				Error:   "Only supported audio formats are allowed",
			})
		}
	case "video":
		if !strings.HasPrefix(contentType, "video/") {
			return c.Status(fiber.StatusBadRequest).JSON(domain.ErrorResponse{
				Message: "Invalid file type",
				Error:   "Only video files are allowed",
			})
		}
	}

	rest, err := io.ReadAll(fh)
	if err != nil {
		return c.Status(fiber.StatusInternalServerError).JSON(domain.ErrorResponse{
			Message: "Failed to read file",
			Error:   err.Error(),
		})
	}
	data := append(head[:n], rest...)

	if mediaType == "video" {
		title := strings.TrimSpace(c.FormValue("title"))
		if title == "" {
			title = fileHeader.Filename
		}
		description := strings.TrimSpace(c.FormValue("description"))
		vimeoUpload, err := h.vimeoSvc.UploadVideoFile(c.Context(), title, description, bytes.NewReader(data), int64(len(data)))
		if err != nil {
			return c.Status(fiber.StatusInternalServerError).JSON(domain.ErrorResponse{
				Message: "Failed to upload video to Vimeo",
				Error:   err.Error(),
			})
		}

		return c.Status(fiber.StatusOK).JSON(domain.Response{
			Message: "Video uploaded successfully",
			Data: uploadMediaRes{
				URL:         vimeoUpload.Link,
				ContentType: contentType,
				MediaType:   mediaType,
				Provider:    "VIMEO",
				VimeoID:     vimeoUpload.VimeoID,
				EmbedURL:    "https://player.vimeo.com/video/" + vimeoUpload.VimeoID,
			},
			Success:    true,
			StatusCode: fiber.StatusOK,
		})
	}

	uploadResult, err := h.minioSvc.Upload(
		c.Context(),
		mediaType,
		fileHeader.Filename,
		bytes.NewReader(data),
		int64(len(data)),
		contentType,
	)
	if err != nil {
		return c.Status(fiber.StatusInternalServerError).JSON(domain.ErrorResponse{
			Message: "Failed to upload file",
			Error:   err.Error(),
		})
	}

	storedPath := "minio://" + uploadResult.ObjectKey
	return c.Status(fiber.StatusOK).JSON(domain.Response{
		Message: "File uploaded successfully",
		Data: uploadMediaRes{
			ObjectKey:   uploadResult.ObjectKey,
			URL:         h.resolveFileURL(c, storedPath),
			ContentType: contentType,
			MediaType:   mediaType,
			Provider:    "MINIO",
		},
		Success:    true,
		StatusCode: fiber.StatusOK,
	})
}

// UploadAudio uploads an audio file to MinIO and returns the object key.
// @Summary Upload an audio file
// @Tags files
// @Accept multipart/form-data
// @Param file formance file true "Audio file (mp3, wav, ogg, m4a, aac, webm)"
// @Success 200 {object} domain.Response
// @Router /api/v1/files/audio [post]
func (h *Handler) UploadAudio(c *fiber.Ctx) error {
	if h.minioSvc == nil {
		return c.Status(fiber.StatusServiceUnavailable).JSON(domain.ErrorResponse{
			Message: "File storage service is not available",
		})
	}

	fileHeader, err := c.FormFile("file")
	if err != nil {
		return c.Status(fiber.StatusBadRequest).JSON(domain.ErrorResponse{
			Message: "Audio file is required",
			Error:   err.Error(),
		})
	}

	const maxSize = 50 * 1024 * 1024 // 50 MB
	if fileHeader.Size > maxSize {
		return c.Status(fiber.StatusBadRequest).JSON(domain.ErrorResponse{
			Message: "File too large",
			Error:   "Audio file must be <= 50MB",
		})
	}

	fh, err := fileHeader.Open()
	if err != nil {
		return c.Status(fiber.StatusInternalServerError).JSON(domain.ErrorResponse{
			Message: "Failed to read file",
			Error:   err.Error(),
		})
	}
	defer fh.Close()

	head := make([]byte, 512)
	n, _ := fh.Read(head)
	contentType := http.DetectContentType(head[:n])

	allowedTypes := map[string]bool{
		"audio/mpeg":  true, // mp3
		"audio/wav":   true,
		"audio/ogg":   true,
		"audio/mp4":   true, // m4a
		"audio/aac":   true,
		"audio/webm":  true,
		"video/ogg":   true, // ogg sometimes detected as video/ogg
		"video/webm":  true, // webm audio sometimes detected as video/webm
		"audio/x-wav": true,
		"audio/x-m4a": true,
		"audio/flac":  true,
	}

	// DetectContentType may return "application/octet-stream" for some audio formats.
	// In that case, fall back to extension-based detection.
	if contentType == "application/octet-stream" {
		ext := strings.ToLower(strings.TrimLeft(strings.ToLower(fileHeader.Filename[strings.LastIndex(fileHeader.Filename, "."):]), "."))
		extMap := map[string]string{
			"mp3":  "audio/mpeg",
			"wav":  "audio/wav",
			"ogg":  "audio/ogg",
			"m4a":  "audio/mp4",
			"aac":  "audio/aac",
			"webm": "audio/webm",
			"flac": "audio/flac",
		}
		if ct, ok := extMap[ext]; ok {
			contentType = ct
		}
	}

	if !allowedTypes[contentType] {
		return c.Status(fiber.StatusBadRequest).JSON(domain.ErrorResponse{
			Message: "Invalid file type",
			Error:   "Only audio files are allowed (mp3, wav, ogg, m4a, aac, webm, flac)",
		})
	}

	rest, err := io.ReadAll(fh)
	if err != nil {
		return c.Status(fiber.StatusInternalServerError).JSON(domain.ErrorResponse{
			Message: "Failed to read file",
			Error:   err.Error(),
		})
	}
	data := append(head[:n], rest...)

	result, err := h.minioSvc.Upload(c.Context(), "audio", fileHeader.Filename, bytes.NewReader(data), int64(len(data)), contentType)
	if err != nil {
		return c.Status(fiber.StatusInternalServerError).JSON(domain.ErrorResponse{
			Message: "Failed to upload audio file",
			Error:   err.Error(),
		})
	}

	storedPath := "minio://" + result.ObjectKey

	return c.Status(fiber.StatusOK).JSON(domain.Response{
		Message: "Audio file uploaded successfully",
		Data: map[string]string{
			"object_key":   result.ObjectKey,
			"url":          h.resolveFileURL(c, storedPath),
			"content_type": contentType,
		},
		Success:    true,
		StatusCode: fiber.StatusOK,
	})
}

// SubmitAudioAnswer allows a learner to upload an audio recording as their answer
// to an AUDIO-type question within a question set (practice).
// @Summary Submit audio answer for a question
// @Tags questions
// @Accept multipart/form-data
// @Param question_id formData int true "Question ID"
// @Param question_set_id formData int true "Question Set ID"
// @Param file formData file true "Audio recording"
// @Success 200 {object} domain.Response
// @Router /api/v1/questions/audio-answer [post]
func (h *Handler) SubmitAudioAnswer(c *fiber.Ctx) error {
	if h.minioSvc == nil {
		return c.Status(fiber.StatusServiceUnavailable).JSON(domain.ErrorResponse{
			Message: "File storage service is not available",
		})
	}

	userID, ok := c.Locals("user_id").(int64)
	if !ok {
		return c.Status(fiber.StatusUnauthorized).JSON(domain.ErrorResponse{
			Message: "Unauthorized",
		})
	}

	// JSON mode: store reference to previously uploaded media key
	if strings.Contains(strings.ToLower(c.Get("Content-Type")), "application/json") {
		var req struct {
			QuestionID    int64  `json:"question_id"`
			QuestionSetID int64  `json:"question_set_id"`
			ObjectKey     string `json:"object_key"`
		}
		if err := c.BodyParser(&req); err != nil {
			return c.Status(fiber.StatusBadRequest).JSON(domain.ErrorResponse{
				Message: "Invalid request body",
				Error:   err.Error(),
			})
		}
		if req.QuestionID <= 0 || req.QuestionSetID <= 0 || strings.TrimSpace(req.ObjectKey) == "" {
			return c.Status(fiber.StatusBadRequest).JSON(domain.ErrorResponse{
				Message: "question_id, question_set_id and object_key are required",
			})
		}

		row, err := h.analyticsDB.CreateUserAudioResponse(c.Context(), dbgen.CreateUserAudioResponseParams{
			UserID:         userID,
			QuestionID:     req.QuestionID,
			QuestionSetID:  req.QuestionSetID,
			AudioObjectKey: req.ObjectKey,
		})
		if err != nil {
			return c.Status(fiber.StatusInternalServerError).JSON(domain.ErrorResponse{
				Message: "Failed to save audio answer",
				Error:   err.Error(),
			})
		}

		audioURL := h.resolveFileURL(c, "minio://"+req.ObjectKey)
		return c.Status(fiber.StatusOK).JSON(domain.Response{
			Message: "Audio answer submitted successfully",
			Data: map[string]interface{}{
				"id":              row.ID,
				"question_id":     row.QuestionID,
				"question_set_id": row.QuestionSetID,
				"audio_url":       audioURL,
				"created_at":      row.CreatedAt,
			},
			Success:    true,
			StatusCode: fiber.StatusOK,
		})
	}

	questionID, err := strconv.ParseInt(c.FormValue("question_id"), 10, 64)
	if err != nil || questionID <= 0 {
		return c.Status(fiber.StatusBadRequest).JSON(domain.ErrorResponse{
			Message: "Invalid question_id",
		})
	}

	questionSetID, err := strconv.ParseInt(c.FormValue("question_set_id"), 10, 64)
	if err != nil || questionSetID <= 0 {
		return c.Status(fiber.StatusBadRequest).JSON(domain.ErrorResponse{
			Message: "Invalid question_set_id",
		})
	}

	fileHeader, err := c.FormFile("file")
	if err != nil {
		return c.Status(fiber.StatusBadRequest).JSON(domain.ErrorResponse{
			Message: "Audio file is required",
			Error:   err.Error(),
		})
	}

	const maxSize = 50 * 1024 * 1024 // 50 MB
	if fileHeader.Size > maxSize {
		return c.Status(fiber.StatusBadRequest).JSON(domain.ErrorResponse{
			Message: "File too large",
			Error:   "Audio file must be <= 50MB",
		})
	}

	fh, err := fileHeader.Open()
	if err != nil {
		return c.Status(fiber.StatusInternalServerError).JSON(domain.ErrorResponse{
			Message: "Failed to read file",
			Error:   err.Error(),
		})
	}
	defer fh.Close()

	head := make([]byte, 512)
	n, _ := fh.Read(head)
	contentType := http.DetectContentType(head[:n])

	// Fallback for audio formats that DetectContentType can't identify
	if contentType == "application/octet-stream" {
		dotIdx := strings.LastIndex(fileHeader.Filename, ".")
		if dotIdx >= 0 {
			ext := strings.ToLower(fileHeader.Filename[dotIdx+1:])
			extMap := map[string]string{
				"mp3": "audio/mpeg", "wav": "audio/wav", "ogg": "audio/ogg",
				"m4a": "audio/mp4", "aac": "audio/aac", "webm": "audio/webm", "flac": "audio/flac",
			}
			if ct, ok := extMap[ext]; ok {
				contentType = ct
			}
		}
	}

	rest, err := io.ReadAll(fh)
	if err != nil {
		return c.Status(fiber.StatusInternalServerError).JSON(domain.ErrorResponse{
			Message: "Failed to read file",
			Error:   err.Error(),
		})
	}
	data := append(head[:n], rest...)

	uploadResult, err := h.minioSvc.Upload(c.Context(), "audio_answers", fileHeader.Filename, bytes.NewReader(data), int64(len(data)), contentType)
	if err != nil {
		return c.Status(fiber.StatusInternalServerError).JSON(domain.ErrorResponse{
			Message: "Failed to upload audio answer",
			Error:   err.Error(),
		})
	}

	row, err := h.analyticsDB.CreateUserAudioResponse(c.Context(), dbgen.CreateUserAudioResponseParams{
		UserID:         userID,
		QuestionID:     questionID,
		QuestionSetID:  questionSetID,
		AudioObjectKey: uploadResult.ObjectKey,
	})
	if err != nil {
		return c.Status(fiber.StatusInternalServerError).JSON(domain.ErrorResponse{
			Message: "Failed to save audio answer",
			Error:   err.Error(),
		})
	}

	audioURL := h.resolveFileURL(c, "minio://"+uploadResult.ObjectKey)

	return c.Status(fiber.StatusOK).JSON(domain.Response{
		Message: "Audio answer submitted successfully",
		Data: map[string]interface{}{
			"id":              row.ID,
			"question_id":     row.QuestionID,
			"question_set_id": row.QuestionSetID,
			"audio_url":       audioURL,
			"created_at":      row.CreatedAt,
		},
		Success:    true,
		StatusCode: fiber.StatusOK,
	})
}