package cps

import (
	"fmt"
	"sync"
)

// Manager provides runtime packet management with caching
type Manager struct {
	compiler *Compiler
	cache    sync.Map // map[string]*CompiledStruct
}

// NewManager creates a packet manager
func NewManager() *Manager {
	return &Manager{}
}

// LoadCSS loads and parses CSS packet definitions
func (m *Manager) LoadCSS(content string) error {
	parser := NewParser(content)
	packets, err := parser.Parse()
	if err != nil {
		return err
	}

	m.compiler = NewCompiler(packets)
	return nil
}

// GetPacket returns a compiled packet structure (cached)
func (m *Manager) GetPacket(name string, version int) (*CompiledStruct, error) {
	key := fmt.Sprintf("%s_%d", name, version)

	if cached, ok := m.cache.Load(key); ok {
		return cached.(*CompiledStruct), nil
	}

	compiled, err := m.compiler.Compile(name, version)
	if err != nil {
		return nil, err
	}

	m.cache.Store(key, compiled)
	return compiled, nil
}

// ListPackets returns names of all available packets
func (m *Manager) ListPackets() []string {
	if m.compiler == nil {
		return nil
	}

	var names []string
	for name := range m.compiler.packets {
		names = append(names, name)
	}
	return names
}

// GetVersions returns all available versions for a packet
func (m *Manager) GetVersions(packetName string) []int {
	if m.compiler == nil {
		return nil
	}

	packet, exists := m.compiler.packets[packetName]
	if !exists {
		return nil
	}

	var versions []int
	for version := range packet.Versions {
		versions = append(versions, version)
	}
	return versions
}

// ClearCache clears the compiled packet cache
func (m *Manager) ClearCache() {
	m.cache = sync.Map{}
}

// Convenience functions

// MustLoadCSS loads CSS definitions and panics on error
func MustLoadCSS(content string) *Manager {
	manager := NewManager()
	if err := manager.LoadCSS(content); err != nil {
		panic(err)
	}
	return manager
}

// QuickSerialize is a convenience function for one-off serialization
func QuickSerialize(manager *Manager, packetName string, version int, data map[string]any) ([]byte, error) {
	serializer := NewSerializer(manager)
	return serializer.Serialize(packetName, version, data)
}

// QuickDeserialize is a convenience function for one-off deserialization
func QuickDeserialize(manager *Manager, packetName string, version int, data []byte) (map[string]any, error) {
	serializer := NewSerializer(manager)
	return serializer.Deserialize(packetName, version, data)
}