package jitie

import (
	"embed"
	"encoding/json"
	"fmt"
	"net/http"
	"toolbox/pkg/base"
	"toolbox/pkg/jitie/logic"

	"github.com/gin-gonic/gin"
)

//go:embed data/all.json
var allDataContent []byte

//go:embed data/*.ttf
var fontFS embed.FS

type jitieTool struct {
	allChars map[string]logic.HanziData
}

func init() {
	base.Register(&jitieTool{})
}

func (t *jitieTool) ID() string          { return "jitie" }
func (t *jitieTool) Name() string        { return "汉字字帖生成" }
func (t *jitieTool) Description() string { return "基于本地 30MB 数据集生成的教学/步进式字帖" }

func (t *jitieTool) Init() error {
	fmt.Println("Loading 30MB character dataset...")
	t.allChars = make(map[string]logic.HanziData)
	if err := json.Unmarshal(allDataContent, &t.allChars); err != nil {
		return fmt.Errorf("failed to unmarshal all.json: %v", err)
	}
	fmt.Printf("Loaded %d characters into memory\n", len(t.allChars))
	
	// Load font for logic layer
	fontBytes, err := fontFS.ReadFile("data/font.ttf")
	if err == nil && len(fontBytes) > 500 { // Check if it's a real font
		logic.SetFontData(fontBytes)
		fmt.Println("Font loaded for numbering")
	} else {
		fmt.Println("Warning: Could not load real font for numbering")
	}
	
	return nil
}

func (t *jitieTool) RegisterRoutes(r *gin.RouterGroup) {
	r.POST("/generate", t.handleGenerate)
}

type GenerateRequest struct {
	Chars     string `json:"chars" binding:"required"`
	Mode      string `json:"mode"`       // "teaching" or "step"
	FlipY     bool   `json:"flip_y"`     
	PaperSize string `json:"paper_size"` // "A4" or "Letter"
}

func (t *jitieTool) handleGenerate(c *gin.Context) {
	var req GenerateRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		return
	}

	var charsData []logic.HanziData
	for _, char := range req.Chars {
		charStr := string(char)
		if data, ok := t.allChars[charStr]; ok {
			data.Character = charStr // Ensure character field is set
			charsData = append(charsData, data)
		} else {
			fmt.Printf("Warning: character %s not found in local dataset\n", charStr)
		}
	}

	if len(charsData) == 0 {
		c.JSON(http.StatusNotFound, gin.H{"error": "no valid character data found in local database"})
		return
	}

	pdfBytes, err := logic.GeneratePDF(charsData, req.Mode, req.PaperSize, req.FlipY)
	if err != nil {
		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
		return
	}

	c.Data(http.StatusOK, "application/pdf", pdfBytes)
}