package spells

import (
	"bytes"
	"embed"
	"encoding/json"
	"fmt"
	"io"
	"strings"

	"gitea.maximumdirect.net/eric/notarius/internal/framework/contracts"
	"gitea.maximumdirect.net/eric/notarius/internal/modules/dnd"
)

const (
	SchemaID      = "notarius.dnd.spells"
	SchemaName    = "notarius_dnd_spells_v1"
	SchemaVersion = "v1"
	MediaType     = "application/json"
)

//go:embed assets/schemas/dnd_spells.v1.json
var schemaAssets embed.FS

var _ contracts.ArtifactCodec[dnd.SpellList] = (*Codec)(nil)

type Codec struct{}

func New() *Codec { return &Codec{} }

func (c *Codec) Kind() contracts.ArtifactKind { return dnd.SpellListKind }

func (c *Codec) Schema() contracts.ArtifactSchema {
	raw, err := schemaAssets.ReadFile("assets/schemas/dnd_spells.v1.json")
	if err != nil {
		return contracts.ArtifactSchema{}
	}
	return contracts.ArtifactSchema{ID: SchemaID, Name: SchemaName, Version: SchemaVersion, JSONSchema: raw}
}

func (c *Codec) MediaType() string { return MediaType }

func (c *Codec) Metadata(value dnd.SpellList) map[string]any {
	return map[string]any{"spell_cast_count": len(value.SpellCasts)}
}

func (c *Codec) Encode(value dnd.SpellList) ([]byte, error) {
	if err := validate(value); err != nil {
		return nil, fmt.Errorf("encode dnd spell list: %w", err)
	}
	return c.EncodeCandidate(value)
}

// EncodeCandidate provides the same stable representation before typed
// validators have approved a value.
func (c *Codec) EncodeCandidate(value dnd.SpellList) ([]byte, error) {
	content, err := json.Marshal(value)
	if err != nil {
		return nil, fmt.Errorf("encode dnd spell list: %w", err)
	}
	return content, nil
}

func (c *Codec) Decode(content []byte) (dnd.SpellList, error) {
	value, err := c.DecodeCandidate(content)
	if err != nil {
		return dnd.SpellList{}, err
	}
	if err := validate(value); err != nil {
		return dnd.SpellList{}, fmt.Errorf("decode dnd spell list: %w", err)
	}
	return value, nil
}

// DecodeCandidate reads the durable representation before semantic validators
// have approved it.
func (c *Codec) DecodeCandidate(content []byte) (dnd.SpellList, error) {
	decoder := json.NewDecoder(bytes.NewReader(content))
	decoder.DisallowUnknownFields()
	var value dnd.SpellList
	if err := decoder.Decode(&value); err != nil {
		return dnd.SpellList{}, fmt.Errorf("decode dnd spell list: %w", err)
	}
	var trailing any
	if err := decoder.Decode(&trailing); err != io.EOF {
		return dnd.SpellList{}, fmt.Errorf("decode dnd spell list: multiple JSON values")
	}
	return value, nil
}

func validate(value dnd.SpellList) error {
	if value.SpellCasts == nil {
		return fmt.Errorf("spell_casts must be present")
	}
	for index, spell := range value.SpellCasts {
		if strings.TrimSpace(spell.Caster) == "" {
			return fmt.Errorf("spell_casts[%d].caster must not be empty", index)
		}
		if strings.TrimSpace(spell.Spell) == "" {
			return fmt.Errorf("spell_casts[%d].spell must not be empty", index)
		}
		if len(spell.SourceRefs) == 0 {
			return fmt.Errorf("spell_casts[%d].source_refs must not be empty", index)
		}
		for refIndex, ref := range spell.SourceRefs {
			if strings.TrimSpace(ref.SourceID) == "" {
				return fmt.Errorf("spell_casts[%d].source_refs[%d].source_id must not be empty", index, refIndex)
			}
			if ref.StartUnitID <= 0 {
				return fmt.Errorf("spell_casts[%d].source_refs[%d].start_unit_id must be positive", index, refIndex)
			}
			if ref.EndUnitID <= 0 {
				return fmt.Errorf("spell_casts[%d].source_refs[%d].end_unit_id must be positive", index, refIndex)
			}
		}
	}
	return nil
}