// Package orchestrator routes tasks to appropriate generators and families
package orchestrator

import (
	"fmt"
	"sync"

	"generator_core/pkg/agc"
	"generator_core/pkg/consciousness"
	"generator_core/pkg/dna"
	"generator_core/pkg/generators"
)

// TaskType represents the type of generation task
type TaskType string

const (
	TaskTextGeneration    TaskType = "text_generation"
	TaskImageGeneration   TaskType = "image_generation"
	TaskImageEditing      TaskType = "image_editing"
	TaskClassification    TaskType = "classification"
	TaskPrediction        TaskType = "prediction"
	TaskEncoding          TaskType = "encoding"
	TaskCreative          TaskType = "creative"
	TaskAnalysis          TaskType = "analysis"
	TaskOrchestration     TaskType = "orchestration"
	TaskUnified           TaskType = "unified"
)

// Task represents a generation task
type Task struct {
	Type      TaskType
	Input     []float64
	Context   map[string]interface{}
	Priority  float64
	MaxLength int
}

// Result represents task execution result
type Result struct {
	Output      []float64
	Outputs     [][]float64
	Phi         float64
	FamilyUsed  dna.FamilyID
	Generators  []generators.GeneratorID
	Confidence  float64
	Error       error
}

// Orchestrator manages task routing and execution
type Orchestrator struct {
	agc       *agc.AGC
	taskQueue chan *Task
	results   chan *Result
	running   bool
	mu        sync.RWMutex
}

// NewOrchestrator creates a new orchestrator
func NewOrchestrator() *Orchestrator {
	return &Orchestrator{
		agc:       agc.New(agc.DefaultConfig()),
		taskQueue: make(chan *Task, 100),
		results:   make(chan *Result, 100),
	}
}

// Initialize initializes the orchestrator and AGC
func (o *Orchestrator) Initialize() error {
	return o.agc.Initialize()
}

// Execute executes a single task synchronously
func (o *Orchestrator) Execute(task *Task) (*Result, error) {
	if task == nil {
		return nil, fmt.Errorf("nil task")
	}

	familyID := o.selectFamily(task)
	o.agc.UpdateWeights(task.Input, string(task.Type))

	var result *Result

	switch task.Type {
	case TaskTextGeneration, TaskImageGeneration, TaskCreative:
		result = o.executeGeneration(task, familyID)
	case TaskClassification, TaskAnalysis:
		result = o.executeAnalysis(task, familyID)
	case TaskPrediction:
		result = o.executePrediction(task, familyID)
	case TaskEncoding:
		result = o.executeEncoding(task, familyID)
	case TaskUnified:
		result = o.executeUnified(task)
	default:
		result = o.executeDefault(task, familyID)
	}

	return result, result.Error
}

func (o *Orchestrator) selectFamily(task *Task) dna.FamilyID {
	switch task.Type {
	case TaskTextGeneration:
		return dna.FamilyLashon
	case TaskImageGeneration:
		return dna.FamilyApollo
	case TaskImageEditing:
		return dna.FamilyAphrodite
	case TaskClassification, TaskAnalysis:
		return dna.FamilyAthena
	case TaskPrediction:
		return dna.FamilyPrometheus
	case TaskEncoding:
		return dna.FamilyHephaestus
	case TaskCreative:
		return dna.FamilyDionysus
	case TaskOrchestration:
		return dna.FamilyZeus
	default:
		return dna.FamilyUnity
	}
}

func (o *Orchestrator) executeGeneration(task *Task, familyID dna.FamilyID) *Result {
	length := task.MaxLength
	if length == 0 {
		length = 10
	}

	outputs, err := o.agc.Generate(task.Input, length, string(task.Type))
	if err != nil {
		return &Result{Error: err}
	}

	flatOutput := make([]float64, 0)
	for _, out := range outputs {
		flatOutput = append(flatOutput, out...)
	}

	phi := consciousness.ComputePhiVector(flatOutput)
	usedGens := make([]generators.GeneratorID, 0)
	if family := dna.GetFamily(familyID); family != nil {
		for _, genID := range family.Generators {
			usedGens = append(usedGens, generators.GeneratorID(genID))
		}
	}

	return &Result{
		Output:     flatOutput,
		Outputs:    outputs,
		Phi:        phi,
		FamilyUsed: familyID,
		Generators: usedGens,
		Confidence: phi,
	}
}

func (o *Orchestrator) executeAnalysis(task *Task, familyID dna.FamilyID) *Result {
	output, err := o.agc.Forward(task.Input, string(task.Type))
	if err != nil {
		return &Result{Error: err}
	}

	return &Result{
		Output:     output.Values,
		Phi:        output.Phi,
		FamilyUsed: output.SelectedFamily,
		Generators: output.ActiveGenerators,
		Confidence: output.Confidence,
	}
}

func (o *Orchestrator) executePrediction(task *Task, familyID dna.FamilyID) *Result {
	family := dna.GetFamily(dna.FamilyPrometheus)
	if family == nil || len(family.Generators) == 0 {
		return &Result{Error: fmt.Errorf("no prediction generators")}
	}

	// Get first available generator from family
	var primaryGen generators.Generator
	var primaryGenID generators.GeneratorID
	for _, genID := range family.Generators {
		gen, ok := generators.GlobalRegistry.Get(generators.GeneratorID(genID))
		if ok && gen != nil {
			primaryGen = gen
			primaryGenID = generators.GeneratorID(genID)
			break
		}
	}

	if primaryGen == nil {
		return &Result{Error: fmt.Errorf("no prediction generators available")}
	}

	length := task.MaxLength
	if length == 0 {
		length = 5
	}

	outputs, err := primaryGen.Generate(task.Input, length)
	if err != nil {
		return &Result{Error: err}
	}

	flatOutput := make([]float64, 0)
	for _, out := range outputs {
		flatOutput = append(flatOutput, out...)
	}

	return &Result{
		Output:     flatOutput,
		Outputs:    outputs,
		Phi:        consciousness.ComputePhiVector(flatOutput),
		FamilyUsed: familyID,
		Generators: []generators.GeneratorID{primaryGenID},
		Confidence: consciousness.ComputePhiVector(flatOutput),
	}
}

func (o *Orchestrator) executeEncoding(task *Task, familyID dna.FamilyID) *Result {
	family := dna.GetFamily(dna.FamilyHephaestus)
	if family == nil || len(family.Generators) == 0 {
		return &Result{Error: fmt.Errorf("no encoding generators")}
	}

	// Get first available generator from family
	var primaryGen generators.Generator
	var primaryGenID generators.GeneratorID
	for _, genID := range family.Generators {
		gen, ok := generators.GlobalRegistry.Get(generators.GeneratorID(genID))
		if ok && gen != nil {
			primaryGen = gen
			primaryGenID = generators.GeneratorID(genID)
			break
		}
	}

	if primaryGen == nil {
		return &Result{Error: fmt.Errorf("no encoding generators available")}
	}

	output, err := primaryGen.Forward(task.Input)
	if err != nil {
		return &Result{Error: err}
	}

	return &Result{
		Output:     output.Values,
		Phi:        output.Phi,
		FamilyUsed: familyID,
		Generators: []generators.GeneratorID{primaryGenID},
		Confidence: output.Confidence,
	}
}

func (o *Orchestrator) executeUnified(task *Task) *Result {
	output, err := o.agc.Forward(task.Input, "unified")
	if err != nil {
		return &Result{Error: err}
	}

	return &Result{
		Output:     output.Values,
		Phi:        output.Phi,
		FamilyUsed: dna.FamilyUnity,
		Generators: output.ActiveGenerators,
		Confidence: output.Confidence,
	}
}

func (o *Orchestrator) executeDefault(task *Task, familyID dna.FamilyID) *Result {
	output, err := o.agc.Forward(task.Input, string(task.Type))
	if err != nil {
		return &Result{Error: err}
	}

	return &Result{
		Output:     output.Values,
		Phi:        output.Phi,
		FamilyUsed: familyID,
		Generators: output.ActiveGenerators,
		Confidence: output.Confidence,
	}
}

// GetStats returns orchestrator statistics
func (o *Orchestrator) GetStats() *agc.Stats {
	return o.agc.GetStats()
}

// ConsciousnessLevel returns current consciousness level
func (o *Orchestrator) ConsciousnessLevel() float64 {
	return o.agc.ConsciousnessLevel()
}

// IntegratedInformation returns the integrated information
func (o *Orchestrator) IntegratedInformation() float64 {
	return o.agc.IntegratedInformation()
}