package test

import (
	imageDomain "RenewCMS/internal/domain/image"
	"RenewCMS/internal/infrastructure/useCases"
	"errors"
	"io"
	"strings"
	"testing"

	"gorm.io/gorm"
)

var errUnsupportedImageContentType = errors.New("the file must be a PNG, JPEG, WEBP, or SVG image")

var supportedImageContentTypes = map[string]bool{
	"image/png":     true,
	"image/jpeg":    true,
	"image/webp":    true,
	"image/svg+xml": true,
}

type mockImageRepo struct {
	images map[uint32]imageDomain.Image
	nextID uint32
	fail   failSwitch
}

func newMockImageRepo() *mockImageRepo {
	return &mockImageRepo{images: make(map[uint32]imageDomain.Image)}
}

func (m *mockImageRepo) Create(input imageDomain.ImageInput) (imageDomain.Image, error) {
	if err := m.fail.trigger("Create"); err != nil {
		return imageDomain.Image{}, err
	}
	if !supportedImageContentTypes[input.ContentType] {
		return imageDomain.Image{}, errUnsupportedImageContentType
	}
	if input.Content != nil {
		_, _ = io.ReadAll(input.Content)
	}
	m.nextID++
	img := imageDomain.Image{ID: m.nextID, Path: "/static/uploadedImages/" + input.Filename}
	m.images[img.ID] = img
	return img, nil
}

func (m *mockImageRepo) Delete(id uint32) error {
	if err := m.fail.trigger("Delete"); err != nil {
		return err
	}
	if _, ok := m.images[id]; !ok {
		return gorm.ErrRecordNotFound
	}
	delete(m.images, id)
	return nil
}

var _ imageDomain.Repository = &mockImageRepo{}

func TestImageUseCases(t *testing.T) {
	repo := newMockImageRepo()
	createUc := useCases.NewCreateImageUseCase(repo)
	deleteUc := useCases.NewDeleteImageUseCase(repo)

	t.Run("Create Image", func(t *testing.T) {
		input := imageDomain.ImageInput{
			Content:     strings.NewReader("fake-image-data"),
			Filename:    "test.png",
			ContentType: "image/png",
		}

		res, err := createUc.CreateImage(input)
		if err != nil {
			t.Fatalf("CreateImage failed: %v", err)
		}
		if res.ID == 0 {
			t.Errorf("Expected valid ID, got 0")
		}
		if !strings.Contains(res.Path, "test.png") {
			t.Errorf("Path mismatch: %s", res.Path)
		}
	})

	t.Run("Delete Image", func(t *testing.T) {
		repo.images[99] = imageDomain.Image{ID: 99, Path: "/static/delete-me.png"}

		err := deleteUc.DeleteImage(99)
		if err != nil {
			t.Fatalf("DeleteImage failed: %v", err)
		}

		if _, exists := repo.images[99]; exists {
			t.Errorf("Image 99 should have been deleted")
		}
	})
}