package assist

import (
	"encoding/json"

	"github.com/readysite/readysite/website/models"
)

// EntityHandler manages CRUD operations for mutation tracking (undo/redo).
type EntityHandler interface {
	// Get retrieves an entity by ID (used to verify existence before delete)
	Get(id string) (any, error)
	// Delete removes an entity by ID
	Delete(id string) error
	// Restore updates an entity from a serialized state
	Restore(id string, state string) error
	// Insert creates an entity from a serialized state
	Insert(state string) error
}

// entityHandlers maps entity types to their handlers.
var entityHandlers = map[string]EntityHandler{
	"page":         pageEntityHandler{},
	"page_content": pageContentEntityHandler{},
	"collection":   collectionEntityHandler{},
	"document":     documentEntityHandler{},
	"partial":      partialEntityHandler{},
	"file":         fileEntityHandler{},
	"note":         noteEntityHandler{},
}

// GetEntityHandler returns the handler for a given entity type.
func GetEntityHandler(entityType string) (EntityHandler, bool) {
	h, ok := entityHandlers[entityType]
	return h, ok
}

// --- Page Handler ---

type pageEntityHandler struct{}

func (h pageEntityHandler) Get(id string) (any, error) {
	return models.Pages.Get(id)
}

func (h pageEntityHandler) Delete(id string) error {
	page, err := models.Pages.Get(id)
	if err != nil {
		return err
	}
	return models.Pages.Delete(page)
}

func (h pageEntityHandler) Restore(id string, state string) error {
	var page models.Page
	if err := json.Unmarshal([]byte(state), &page); err != nil {
		return err
	}
	page.ID = id
	return models.Pages.Update(&page)
}

func (h pageEntityHandler) Insert(state string) error {
	var page models.Page
	if err := json.Unmarshal([]byte(state), &page); err != nil {
		return err
	}
	_, err := models.Pages.Insert(&page)
	return err
}

// --- PageContent Handler ---

type pageContentEntityHandler struct{}

func (h pageContentEntityHandler) Get(id string) (any, error) {
	return models.PageContents.Get(id)
}

func (h pageContentEntityHandler) Delete(id string) error {
	pc, err := models.PageContents.Get(id)
	if err != nil {
		return err
	}
	return models.PageContents.Delete(pc)
}

func (h pageContentEntityHandler) Restore(id string, state string) error {
	var pc models.PageContent
	if err := json.Unmarshal([]byte(state), &pc); err != nil {
		return err
	}
	pc.ID = id
	return models.PageContents.Update(&pc)
}

func (h pageContentEntityHandler) Insert(state string) error {
	var pc models.PageContent
	if err := json.Unmarshal([]byte(state), &pc); err != nil {
		return err
	}
	_, err := models.PageContents.Insert(&pc)
	return err
}

// --- Collection Handler ---

type collectionEntityHandler struct{}

func (h collectionEntityHandler) Get(id string) (any, error) {
	return models.Collections.Get(id)
}

func (h collectionEntityHandler) Delete(id string) error {
	col, err := models.Collections.Get(id)
	if err != nil {
		return err
	}
	return models.Collections.Delete(col)
}

func (h collectionEntityHandler) Restore(id string, state string) error {
	var col models.Collection
	if err := json.Unmarshal([]byte(state), &col); err != nil {
		return err
	}
	col.ID = id
	return models.Collections.Update(&col)
}

func (h collectionEntityHandler) Insert(state string) error {
	var col models.Collection
	if err := json.Unmarshal([]byte(state), &col); err != nil {
		return err
	}
	_, err := models.Collections.Insert(&col)
	return err
}

// --- Document Handler ---

type documentEntityHandler struct{}

func (h documentEntityHandler) Get(id string) (any, error) {
	return models.Documents.Get(id)
}

func (h documentEntityHandler) Delete(id string) error {
	doc, err := models.Documents.Get(id)
	if err != nil {
		return err
	}
	return models.Documents.Delete(doc)
}

func (h documentEntityHandler) Restore(id string, state string) error {
	var doc models.Document
	if err := json.Unmarshal([]byte(state), &doc); err != nil {
		return err
	}
	doc.ID = id
	return models.Documents.Update(&doc)
}

func (h documentEntityHandler) Insert(state string) error {
	var doc models.Document
	if err := json.Unmarshal([]byte(state), &doc); err != nil {
		return err
	}
	_, err := models.Documents.Insert(&doc)
	return err
}

// --- Partial Handler ---

type partialEntityHandler struct{}

func (h partialEntityHandler) Get(id string) (any, error) {
	return models.Partials.Get(id)
}

func (h partialEntityHandler) Delete(id string) error {
	partial, err := models.Partials.Get(id)
	if err != nil {
		return err
	}
	return models.Partials.Delete(partial)
}

func (h partialEntityHandler) Restore(id string, state string) error {
	var partial models.Partial
	if err := json.Unmarshal([]byte(state), &partial); err != nil {
		return err
	}
	partial.ID = id
	return models.Partials.Update(&partial)
}

func (h partialEntityHandler) Insert(state string) error {
	var partial models.Partial
	if err := json.Unmarshal([]byte(state), &partial); err != nil {
		return err
	}
	_, err := models.Partials.Insert(&partial)
	return err
}

// --- File Handler ---

type fileEntityHandler struct{}

func (h fileEntityHandler) Get(id string) (any, error) {
	return models.Files.Get(id)
}

func (h fileEntityHandler) Delete(id string) error {
	file, err := models.Files.Get(id)
	if err != nil {
		return err
	}
	return models.Files.Delete(file)
}

func (h fileEntityHandler) Restore(id string, state string) error {
	var file models.File
	if err := json.Unmarshal([]byte(state), &file); err != nil {
		return err
	}
	file.ID = id
	return models.Files.Update(&file)
}

func (h fileEntityHandler) Insert(state string) error {
	var file models.File
	if err := json.Unmarshal([]byte(state), &file); err != nil {
		return err
	}
	_, err := models.Files.Insert(&file)
	return err
}

// --- Note Handler ---

type noteEntityHandler struct{}

func (h noteEntityHandler) Get(id string) (any, error) {
	return models.Notes.Get(id)
}

func (h noteEntityHandler) Delete(id string) error {
	note, err := models.Notes.Get(id)
	if err != nil {
		return err
	}
	return models.Notes.Delete(note)
}

func (h noteEntityHandler) Restore(id string, state string) error {
	var note models.Note
	if err := json.Unmarshal([]byte(state), &note); err != nil {
		return err
	}
	note.ID = id
	return models.Notes.Update(&note)
}

func (h noteEntityHandler) Insert(state string) error {
	var note models.Note
	if err := json.Unmarshal([]byte(state), &note); err != nil {
		return err
	}
	_, err := models.Notes.Insert(&note)
	return err
}