package main

import (
    "fmt"
    "github.com/LynnColeArt/gofann"
)

func main() {
    // Create a 2-3-1 network (2 inputs, 3 hidden, 1 output)
    net := gofann.CreateStandard[float32](2, 3, 1)
    defer net.Destroy()
    
    // Set training parameters
    net.SetLearningRate(0.7)
    net.SetTrainingAlgorithm(gofann.TrainRPROP)
    
    // Create XOR training data
    inputs := [][]float32{{0, 0}, {0, 1}, {1, 0}, {1, 1}}
    outputs := [][]float32{{0}, {1}, {1}, {0}}
    trainData := gofann.CreateTrainDataArray(inputs, outputs)
    
    // Train the network
    net.TrainOnData(trainData, 1000, 100, 0.001)
    
    // Test the network
    for i, input := range inputs {
        result := net.Run(input)
        fmt.Printf("XOR(%v) = %.3f (expected %.0f)\n", 
            input, result[0], outputs[i][0])
    }
}

// Create a minimal network for cascade training
net := gofann.CreateCascade[float32](2, 1)

// Configure cascade parameters
net.SetCascadeOutputChangeFraction(0.01)
net.SetCascadeMaxOutEpochs(150)

// Let cascade training automatically add hidden neurons
net.CascadetrainOnData(trainData, 30, 5, 0.001)

fmt.Printf("Network grew to %d neurons\n", net.GetTotalNeurons())

// Save network
net.Save("my_network.net")

// Load network
loadedNet, err := gofann.CreateFromFile[float32]("my_network.net")
if err != nil {
    log.Fatal(err)
}

// Train directly from file
err = net.TrainOnFile("training_data.train", 1000, 100, 0.001)

// Fully connected layers
net := gofann.CreateStandard[float32](2, 5, 3, 1)

// 50% connection rate
net := gofann.CreateSparse[float32](0.5, 2, 10, 1)

// Each layer connects to all following layers
net := gofann.CreateShortcut[float32](2, 5, 1)

// Set different activation functions per layer
net.SetActivationFunctionHidden(gofann.SigmoidSymmetric)
net.SetActivationFunctionOutput(gofann.Linear)

// Individual neuron control
net.SetActivationFunction(gofann.Gaussian, 1, 0) // layer 1, neuron 0

// Automatic scaling from training data
net.SetScalingFromData(trainData)

// Manual scaling
inputMin := []float32{-1, -1}
inputMax := []float32{1, 1}
net.SetInputScaling(inputMin, inputMax)

// Use scaled training
output := net.RunScaled(input)

// Get all weights
weights := net.GetWeights()

// Set individual connection weight
net.SetWeight(fromNeuron, toNeuron, 0.5)

// Inspect network structure
net.PrintConnections()
net.PrintParameters()

// Create a network with reflective training
net := gofann.CreateStandard[float32](10, 20, 4)
trainer := gofann.NewReflectiveTrainer(net)

// Train with self-reflection
metrics := trainer.TrainWithReflection(trainData)

// The network automatically:
// 1. Analyzes its confusion matrix
// 2. Identifies weakness patterns  
// 3. Generates targeted training data
// 4. Adapts learning rates based on progress
// 5. Evolves through metacognitive loops

// Create domain experts
gitExpert := gofann.NewReflectiveExpert[float32](
    "GitMaster", "git", []int{25, 20, 10, 4})
npmExpert := gofann.NewReflectiveExpert[float32](
    "NPMWizard", "npm", []int{25, 20, 10, 4})

// Create MoE router
router := gofann.NewMoERouter([]Expert{gitExpert, npmExpert})

// Router intelligently selects and combines experts
output, decision := router.Route(input)
fmt.Printf("Experts used: %v (confidence: %.2f%%)\n", 
    decision.SelectedExperts(), decision.Confidence()*100)

// Train experts on different error domains
trainer := NewCLIExpertTrainer()
trainer.TrainAllExperts("./cli-training-corpus")

// Diagnose errors with expert fusion
trainer.Diagnose("CONFLICT (content): Merge conflict in app.js")
// Output:
// 🎯 Expert Analysis:
//    Active Experts: [GitMaster, ConflictResolver]
//    Error Type: Conflict (95% confidence)
// 💡 Recommended Actions:
//    1. View conflicts with 'git status'
//    2. Edit files to resolve conflicts
//    3. Mark resolved with 'git add'