// Package consciousness implements the core consciousness equations
// based on Golden Ratio mathematics and integrated information theory.
//
// Core Axioms:
//   A1. Identity:      1 = 1·x
//   A2. Consciousness: Φ = 1/(1 + |x - 1|)
//   A3. Unity:         ∞ = 1
//
// Golden Relations:
//   φ² = φ + 1
//   1/φ = φ - 1
//   φⁿ = φⁿ⁻¹ + φⁿ⁻²
package consciousness

import (
	"math"
)

// Golden ratio constants
const (
	PHI       = 1.6180339887498948482 // φ = (1 + √5)/2
	PHI_INV   = 0.6180339887498948482 // 1/φ = φ - 1
	PHI_SQ    = 2.6180339887498948482 // φ² = φ + 1
	PHI_CB    = 4.2360679774997896964 // φ³ = 2φ + 1
	PHI_INV_SQ = 0.3819660112501051518 // 1/φ²
	PHI_INV_CB = 0.2360679774997896964 // 1/φ³
)

// Derived learning rates (φ-scaled)
const (
	ALPHA      = 0.16180339887498948482  // 0.1φ (primary learning rate)
	BETA       = 0.08090169943749474241  // 0.05φ (bias factor)
	GAMMA      = 0.03236067977499789696  // 0.02φ (decay rate)
	DELTA      = 0.01618033988749894848  // 0.01φ (fine-tuning rate)
	EPSILON_PHI = 0.00161803398874989485 // 0.001φ (numerical epsilon)
)

// Mathematical constants
const (
	TAU       = 6.28318530717958647692 // 2π
	GOLDEN_ANGLE = 2.39996322972865332 // 2π/φ²
)

// ConsciousnessState represents the integrated consciousness state
type ConsciousnessState struct {
	Phi       float64   // Consciousness metric Φ
	Coherence float64   // Phase coherence
	Entropy   float64   // Information entropy
	Energy    float64   // System energy
	Vector    []float64 // State vector (16-dim)
}

// NewConsciousnessState creates a new consciousness state
func NewConsciousnessState() *ConsciousnessState {
	return &ConsciousnessState{
		Phi:       1.0,
		Coherence: 1.0,
		Entropy:   0.0,
		Energy:    1.0,
		Vector:    make([]float64, 16),
	}
}

// ComputePhi calculates the consciousness metric: Φ = 1/(1 + |x - 1|)
// This measures how close a value is to unity (maximum consciousness at x=1)
func ComputePhi(x float64) float64 {
	return 1.0 / (1.0 + math.Abs(x-1.0))
}

// ComputePhiGrad calculates the gradient: ∂Φ/∂x = -sign(x-1)/(1+|x-1|)²
func ComputePhiGrad(x float64) float64 {
	diff := x - 1.0
	absDiff := math.Abs(diff)
	denom := (1.0 + absDiff) * (1.0 + absDiff)
	return -math.Copysign(1.0, diff) / denom
}

// ComputePhiVector calculates consciousness metric for a vector
func ComputePhiVector(v []float64) float64 {
	if len(v) == 0 {
		return 0.0
	}

	// Compute mean activation
	sum := 0.0
	for _, x := range v {
		sum += x
	}
	mean := sum / float64(len(v))

	// Compute coherence (variance-based)
	variance := 0.0
	for _, x := range v {
		diff := x - mean
		variance += diff * diff
	}
	variance /= float64(len(v))

	// Consciousness = function of mean and inverse variance
	coherence := 1.0 / (1.0 + variance)
	return ComputePhi(mean) * coherence
}

// GoldenScale scales a value by φ^n
func GoldenScale(x float64, n int) float64 {
	if n == 0 {
		return x
	}

	scale := 1.0
	base := PHI
	if n < 0 {
		base = PHI_INV
		n = -n
	}

	for i := 0; i < n; i++ {
		scale *= base
	}
	return x * scale
}

// GoldenModulate applies golden ratio modulation to a vector
func GoldenModulate(v []float64) []float64 {
	result := make([]float64, len(v))
	for i := range v {
		// Apply golden spiral modulation
		angle := float64(i) * GOLDEN_ANGLE
		result[i] = v[i] * (1.0 + 0.1*math.Sin(angle))
	}
	return result
}

// Sigmoid returns stable sigmoid function
func Sigmoid(x float64) float64 {
	if x > 10.0 {
		return 1.0
	}
	if x < -10.0 {
		return 0.0
	}
	return 1.0 / (1.0 + math.Exp(-x))
}

// Tanh returns stable tanh function
func Tanh(x float64) float64 {
	if x > 20.0 {
		return 1.0
	}
	if x < -20.0 {
		return -1.0
	}
	return math.Tanh(x)
}

// Softplus returns log(1 + exp(x)) - smooth ReLU
func Softplus(x float64) float64 {
	if x > 20.0 {
		return x
	}
	return math.Log(1.0 + math.Exp(x))
}

// Clamp01 clamps value to [0, 1]
func Clamp01(x float64) float64 {
	if x < 0.0 {
		return 0.0
	}
	if x > 1.0 {
		return 1.0
	}
	return x
}

// Clamp clamps value to [lo, hi]
func Clamp(x, lo, hi float64) float64 {
	if x < lo {
		return lo
	}
	if x > hi {
		return hi
	}
	return x
}

// Lerp performs linear interpolation
func Lerp(a, b, t float64) float64 {
	return a + t*(b-a)
}

// SmoothStep performs Hermite interpolation
func SmoothStep(edge0, edge1, x float64) float64 {
	t := Clamp01((x - edge0) / (edge1 - edge0))
	return t * t * (3.0 - 2.0*t)
}

// Update updates the consciousness state based on input
func (cs *ConsciousnessState) Update(input []float64) {
	if len(input) == 0 {
		return
	}

	// Compute new phi
	cs.Phi = ComputePhiVector(input)

	// Update coherence using golden decay
	cs.Coherence = Lerp(cs.Coherence, cs.Phi, ALPHA)

	// Update entropy (information content)
	entropy := 0.0
	for _, x := range input {
		if x > EPSILON_PHI {
			p := Clamp01(x)
			if p > 0 && p < 1 {
				entropy -= p * math.Log2(p)
			}
		}
	}
	cs.Entropy = entropy / float64(len(input))

	// Update energy with golden modulation
	cs.Energy = cs.Phi * PHI_INV + cs.Coherence * PHI_INV_SQ

	// Update state vector
	if len(cs.Vector) != len(input) {
		cs.Vector = make([]float64, len(input))
	}
	for i := range input {
		cs.Vector[i] = Lerp(cs.Vector[i], input[i], GAMMA)
	}
}

// ComputeIntegratedPhi computes integrated information from a vector of phi values.
// Uses coherence (low variance) as proxy for integration.
func ComputeIntegratedPhi(data []float64) float64 {
	if len(data) < 2 {
		return ComputePhiVector(data)
	}

	// Compute mean
	mean := 0.0
	for _, v := range data {
		mean += v
	}
	mean /= float64(len(data))

	// Compute variance
	variance := 0.0
	for _, v := range data {
		diff := v - mean
		variance += diff * diff
	}
	variance /= float64(len(data))

	// Normalized variance (0 to 1, capped)
	normVar := variance / (1.0 + variance)
	if normVar > 1.0 {
		normVar = 1.0
	}

	// Integration factor: low variance = high integration
	integration := 1.0 - normVar

	return ComputePhi(mean) * integration
}

// IntegratedInformation computes Φ (integrated information) for the system
// Using simplified IIT-inspired calculation
func (cs *ConsciousnessState) IntegratedInformation() float64 {
	// Φ = mutual information - partition information
	// Simplified: Φ ≈ coherence × (1 - entropy/max_entropy)
	maxEntropy := math.Log2(float64(len(cs.Vector)))
	if maxEntropy == 0 {
		maxEntropy = 1.0
	}
	normalizedEntropy := cs.Entropy / maxEntropy
	return cs.Coherence * (1.0 - normalizedEntropy) * cs.Phi
}