// SPF Smart Gateway - Full Transformer Model
// Copyright 2026 Joseph Stone - All Rights Reserved
//
// Complete encoder-decoder transformer with two configurations:
//   Writer:     Operational — tool selection, gate prediction, task execution
//   Researcher: Conversational — chat, analysis, question answering
//
// Both share the same architecture (d_model=256, n_heads=8, n_layers=6).
// Difference is in training data and task framing, not model structure.
//
// Depends on: tensor.rs, tokenizer.rs, attention.rs, ffn.rs, encoder.rs, decoder.rs

use crate::tensor::Tensor;
use crate::tokenizer::{self, Tokenizer, BOS_ID, EOS_ID, PAD_ID};
use crate::encoder::{Encoder, EncoderConfig};
use crate::decoder::{Decoder, DecoderConfig, DecoderLayerCache};

// ============================================================================
// FORWARD CACHE (for backward pass — P2-C)
// ============================================================================

/// Cached activations from full model forward pass (causal mode)
pub struct ForwardCache {
    /// Token indices used for embedding (for embedding_backward)
    pub token_indices: Vec<u32>,
    /// Embedded tokens [batch, seq, d_model]
    pub embedded: Tensor,
    /// Per-layer decoder caches
    pub decoder_caches: Vec<DecoderLayerCache>,
    /// Decoder output before projection [batch, seq, d_model]
    pub decoder_output: Tensor,
}

// ============================================================================
// TRANSFORMER CONFIGURATION
// ============================================================================

/// Configuration for the SPF Transformer
#[derive(Debug, Clone)]
pub struct TransformerModelConfig {
    /// Model dimension
    pub d_model: usize,
    /// Number of attention heads
    pub n_heads: usize,
    /// Number of encoder/decoder layers
    pub n_layers: usize,
    /// Feed-forward hidden dimension (typically 4× d_model)
    pub d_ff: usize,
    /// Vocabulary size (from tokenizer)
    pub vocab_size: usize,
    /// Maximum sequence length
    pub max_seq_len: usize,
    /// Layer norm epsilon
    pub ln_eps: f32,
}

impl TransformerModelConfig {
    /// SPF Writer default: ~5M params
    /// d_model=256, n_heads=8, n_layers=6, d_ff=1024, vocab=8192, max_seq=2048
    pub fn spf_writer() -> Self {
        Self {
            d_model: 256,
            n_heads: 8,
            n_layers: 6,
            d_ff: 1024,
            vocab_size: 8192,
            max_seq_len: 2048,
            ln_eps: 1e-5,
        }
    }

    /// SPF Researcher: same architecture, different training
    pub fn spf_researcher() -> Self {
        Self::spf_writer() // Same structure — role determined by training data
    }

    /// Small config for testing
    pub fn small() -> Self {
        Self {
            d_model: 64,
            n_heads: 4,
            n_layers: 2,
            d_ff: 256,
            vocab_size: 512,
            max_seq_len: 128,
            ln_eps: 1e-5,
        }
    }

    /// Estimate total parameter count
    pub fn estimate_params(&self) -> usize {
        let d = self.d_model;
        let ff = self.d_ff;
        let v = self.vocab_size;
        let n = self.n_layers;

        // Token embedding: vocab × d_model
        let embed_params = v * d;

        // Per encoder layer: attn(4d² + 4d) + ffn(2*d*ff + ff + d) + LN(4d)
        let enc_layer = 4 * d * d + 4 * d + 2 * d * ff + ff + d + 4 * d;

        // Per decoder layer: self_attn + cross_attn + ffn + LN(6d)
        let dec_layer = 2 * (4 * d * d + 4 * d) + 2 * d * ff + ff + d + 6 * d;

        // Output projection: d × vocab
        let output_params = d * v;

        // Final layer norms: encoder(2d) + decoder(2d)
        let final_ln = 4 * d;

        embed_params + n * enc_layer + n * dec_layer + output_params + final_ln
    }
}

// ============================================================================
// SPF TRANSFORMER
// ============================================================================

/// The complete SPF Transformer model.
///
/// Architecture: Token Embedding → Encoder → Decoder → Output Projection
///
/// For encoder-decoder mode (Writer):
///   input tokens → embed → encoder → decoder(with cross-attn) → logits
///
/// For decoder-only mode (Researcher):
///   input tokens → embed → decoder(causal, no cross-attn) → logits
pub struct SPFTransformer {
    pub config: TransformerModelConfig,
    /// Token embedding matrix: [vocab_size, d_model]
    pub token_embedding: Tensor,
    /// Encoder stack
    pub encoder: Encoder,
    /// Decoder stack
    pub decoder: Decoder,
    /// Output projection: [d_model, vocab_size] (tied with embedding transpose)
    pub output_projection: Tensor,
    /// Output bias: [vocab_size]
    pub output_bias: Tensor,
}

impl SPFTransformer {
    /// Initialize a new transformer with random weights
    pub fn new(config: TransformerModelConfig, seed: u64) -> Self {
        let enc_config = EncoderConfig {
            n_layers: config.n_layers,
            d_model: config.d_model,
            n_heads: config.n_heads,
            d_ff: config.d_ff,
            max_seq_len: config.max_seq_len,
            ln_eps: config.ln_eps,
        };
        let dec_config = DecoderConfig {
            n_layers: config.n_layers,
            d_model: config.d_model,
            n_heads: config.n_heads,
            d_ff: config.d_ff,
            max_seq_len: config.max_seq_len,
            ln_eps: config.ln_eps,
        };

        // Xavier init for embeddings
        let embed_scale = (6.0 / (config.vocab_size + config.d_model) as f32).sqrt();
        let proj_scale = (6.0 / (config.d_model + config.vocab_size) as f32).sqrt();

        Self {
            token_embedding: Tensor::randn(
                &[config.vocab_size, config.d_model], seed
            ).scale(embed_scale),
            encoder: Encoder::new(enc_config, seed + 10000),
            decoder: Decoder::new(dec_config, seed + 20000),
            output_projection: Tensor::randn(
                &[config.vocab_size, config.d_model], seed + 30000
            ).scale(proj_scale),
            output_bias: Tensor::zeros(&[config.vocab_size]),
            config,
        }
    }

    /// Embed token IDs into dense vectors
    /// input_ids: [batch, seq_len] as flat Vec<u32>
    /// Returns: [batch, seq_len, d_model]
    fn embed_tokens(&self, input_ids: &[u32], batch: usize, seq_len: usize) -> Result<Tensor, String> {
        let d = self.config.d_model;
        let v = self.config.vocab_size;
        let mut data = Vec::with_capacity(batch * seq_len * d);

        for &id in input_ids {
            if (id as usize) >= v {
                return Err(format!("Token ID {} exceeds vocab size {}", id, v));
            }
            let offset = (id as usize) * d;
            data.extend_from_slice(&self.token_embedding.data[offset..offset + d]);
        }

        Tensor::from_data(data, vec![batch, seq_len, d])
    }

    /// Forward pass (encoder-decoder mode)
    /// enc_ids: encoder input token IDs [batch × enc_seq]
    /// dec_ids: decoder input token IDs [batch × dec_seq]
    /// Returns: logits [batch, dec_seq, vocab_size]
    pub fn forward(
        &self,
        enc_ids: &[u32], enc_batch: usize, enc_seq: usize,
        dec_ids: &[u32], dec_batch: usize, dec_seq: usize,
    ) -> Result<Tensor, String> {
        if enc_batch != dec_batch {
            return Err("Encoder and decoder batch sizes must match".to_string());
        }

        // Embed tokens
        let enc_emb = self.embed_tokens(enc_ids, enc_batch, enc_seq)?;
        let dec_emb = self.embed_tokens(dec_ids, dec_batch, dec_seq)?;

        // Encode
        let enc_out = self.encoder.forward(&enc_emb)?;

        // Decode with cross-attention to encoder output
        let dec_out = self.decoder.forward(&dec_emb, &enc_out)?;

        // Project to vocabulary logits
        self.project_to_logits(&dec_out)
    }

    /// Forward pass (decoder-only / causal LM mode)
    /// Used by Researcher transformer for chat/analysis
    /// ids: input token IDs [batch × seq]
    /// Returns: logits [batch, seq, vocab_size]
    pub fn forward_causal(
        &self,
        ids: &[u32], batch: usize, seq: usize,
    ) -> Result<Tensor, String> {
        let emb = self.embed_tokens(ids, batch, seq)?;
        let dec_out = self.decoder.forward_causal(&emb)?;
        self.project_to_logits(&dec_out)
    }

    /// Forward pass (decoder-only / causal) with cached activations for backward.
    /// Output is IDENTICAL to forward_causal(). Cache is additional data only.
    pub fn forward_causal_with_cache(
        &self,
        ids: &[u32], batch: usize, seq: usize,
    ) -> Result<(Tensor, ForwardCache), String> {
        let token_indices = ids.to_vec();
        let emb = self.embed_tokens(ids, batch, seq)?;
        let embedded = emb.clone();
        let (dec_out, decoder_caches) = self.decoder.forward_causal_with_cache(&emb)?;
        let decoder_output = dec_out.clone();
        let logits = self.project_to_logits(&dec_out)?;

        let cache = ForwardCache {
            token_indices,
            embedded,
            decoder_caches,
            decoder_output,
        };

        Ok((logits, cache))
    }

    /// Project decoder output to vocabulary logits
    /// dec_out: [batch, seq, d_model]
    /// Returns: [batch, seq, vocab_size]
    fn project_to_logits(&self, dec_out: &Tensor) -> Result<Tensor, String> {
        let batch = dec_out.shape[0];
        let seq = dec_out.shape[1];
        let d = dec_out.shape[2];
        let v = self.config.vocab_size;

        // Reshape to [batch*seq, d_model]
        let flat = dec_out.reshape(&[batch * seq, d])?;

        // output_projection is [vocab_size, d_model] — transpose for matmul
        // [batch*seq, d_model] × [d_model, vocab_size] = [batch*seq, vocab_size]
        let logits = flat.matmul(&self.output_projection.transpose_2d()?)?;

        // Add bias and reshape
        let biased = logits.add(&self.expand_bias(&self.output_bias, batch * seq))?;
        biased.reshape(&[batch, seq, v])
    }

    /// Autoregressive generation: given prompt tokens, generate up to max_tokens
    /// Returns generated token IDs (including prompt)
    pub fn generate(
        &self,
        prompt_ids: &[u32],
        max_tokens: usize,
        temperature: f32,
        seed: u64,
    ) -> Result<Vec<u32>, String> {
        let mut ids = prompt_ids.to_vec();
        let mut rng_state = seed;

        // Auto-prepend BOS if not already present
        if ids.is_empty() || ids[0] != BOS_ID {
            ids.insert(0, BOS_ID);
        }

        for _ in 0..max_tokens {
            let seq_len = ids.len();
            if seq_len >= self.config.max_seq_len {
                break;
            }

            // Forward pass on current sequence
            let logits = self.forward_causal(&ids, 1, seq_len)?;

            // Get logits for last position: [vocab_size]
            let last_offset = (seq_len - 1) * self.config.vocab_size;
            let last_logits = &logits.data[last_offset..last_offset + self.config.vocab_size];

            // Apply temperature
            let scaled: Vec<f32> = if temperature > 0.0 {
                last_logits.iter().map(|&l| l / temperature).collect()
            } else {
                last_logits.to_vec()
            };

            // Softmax to get probabilities
            let logit_tensor = Tensor::from_data(scaled, vec![self.config.vocab_size])?;
            let probs = logit_tensor.softmax()?;

            // Sample from distribution (or argmax if temperature=0)
            let next_id = if temperature <= 0.0 {
                probs.argmax()[0] as u32
            } else {
                // Weighted random sampling
                rng_state = xorshift64(rng_state);
                let r = (rng_state as f32) / (u64::MAX as f32);
                let mut cumsum = 0.0;
                let mut sampled = 0u32;
                for (i, &p) in probs.data.iter().enumerate() {
                    cumsum += p;
                    if cumsum >= r {
                        sampled = i as u32;
                        break;
                    }
                }
                sampled
            };

            // Stop on EOS
            if next_id == EOS_ID {
                ids.push(next_id);
                break;
            }

            ids.push(next_id);
        }

        // Strip PAD tokens from output
        ids.retain(|&id| id != PAD_ID);

        Ok(ids)
    }

    /// Convenience: tokenize, generate, decode in one call
    pub fn generate_text(
        &self,
        prompt: &str,
        max_tokens: usize,
        temperature: f32,
        seed: u64,
        tokenizer: &Tokenizer,
    ) -> Result<String, String> {
        let input_ids = tokenizer.encode(prompt);
        let output_ids = self.generate(&input_ids, max_tokens, temperature, seed)?;
        Ok(tokenizer.decode(&output_ids[input_ids.len()..]))
    }

    /// Generate a gate decision using SPF special tokens.
    /// The Writer transformer's core function: given tool context,
    /// predict ALLOWED or BLOCKED using structured token output.
    ///
    /// Returns: (output_ids, allowed: bool)
    pub fn generate_gate_decision(
        &self,
        context_ids: &[u32],
        max_tokens: usize,
        seed: u64,
    ) -> Result<(Vec<u32>, bool), String> {
        // Frame as gate decision: [BOS] [GATE] [TOOL] <context> → [ALLOWED] or [BLOCKED]
        let mut ids = vec![BOS_ID, tokenizer::GATE_ID, tokenizer::TOOL_ID];
        ids.extend_from_slice(context_ids);

        let output = self.generate(&ids, max_tokens, 0.3, seed)?;

        // Scan output for gate decision tokens
        let has_allowed = output.iter().any(|&id| id == tokenizer::ALLOWED_ID);
        let has_blocked = output.iter().any(|&id| id == tokenizer::BLOCKED_ID);

        // BLOCKED takes priority (security conservative)
        let allowed = has_allowed && !has_blocked;

        Ok((output, allowed))
    }

    /// Expand bias for matmul addition
    fn expand_bias(&self, bias: &Tensor, n_rows: usize) -> Tensor {
        let d = bias.numel();
        let mut data = Vec::with_capacity(n_rows * d);
        for _ in 0..n_rows {
            data.extend_from_slice(&bias.data);
        }
        Tensor { data, shape: vec![n_rows, d] }
    }

    /// Total number of parameters
    pub fn num_params(&self) -> usize {
        let embed = self.token_embedding.numel();
        let enc = self.encoder.num_params();
        let dec = self.decoder.num_params();
        let proj = self.output_projection.numel() + self.output_bias.numel();
        embed + enc + dec + proj
    }

    /// Collect all weight tensors for serialization
    pub fn weights(&self) -> Vec<&Tensor> {
        let mut w: Vec<&Tensor> = vec![&self.token_embedding];
        w.extend(self.encoder.weights());
        w.extend(self.decoder.weights());
        w.push(&self.output_projection);
        w.push(&self.output_bias);
        w
    }

    /// Collect all weight tensors mutably for optimizer updates
    pub fn weights_mut(&mut self) -> Vec<&mut Tensor> {
        let mut w: Vec<&mut Tensor> = vec![&mut self.token_embedding];
        w.extend(self.encoder.weights_mut());
        w.extend(self.decoder.weights_mut());
        w.push(&mut self.output_projection);
        w.push(&mut self.output_bias);
        w
    }
}

/// xorshift64 PRNG for generation sampling
fn xorshift64(mut state: u64) -> u64 {
    state ^= state << 13;
    state ^= state >> 7;
    state ^= state << 17;
    state
}

// ============================================================================
// TESTS
// ============================================================================

#[cfg(test)]
mod tests {
    use super::*;

    fn small_config() -> TransformerModelConfig {
        TransformerModelConfig::small()
    }

    #[test]
    fn test_forward_causal_shape() {
        let config = small_config();
        let model = SPFTransformer::new(config.clone(), 42);
        let ids: Vec<u32> = vec![1, 10, 20, 30]; // BOS + 3 tokens
        let logits = model.forward_causal(&ids, 1, 4).unwrap();
        assert_eq!(logits.shape, vec![1, 4, config.vocab_size]);
    }

    #[test]
    fn test_forward_encoder_decoder_shape() {
        let config = small_config();
        let model = SPFTransformer::new(config.clone(), 42);
        let enc_ids: Vec<u32> = vec![1, 10, 20, 30, 2]; // BOS + tokens + EOS
        let dec_ids: Vec<u32> = vec![1, 40, 50];          // BOS + tokens
        let logits = model.forward(
            &enc_ids, 1, 5,
            &dec_ids, 1, 3,
        ).unwrap();
        assert_eq!(logits.shape, vec![1, 3, config.vocab_size]);
    }

    #[test]
    fn test_logits_finite() {
        let model = SPFTransformer::new(small_config(), 42);
        let ids: Vec<u32> = vec![1, 5, 10];
        let logits = model.forward_causal(&ids, 1, 3).unwrap();
        assert!(logits.data.iter().all(|v| v.is_finite()));
    }

    #[test]
    fn test_generate_produces_tokens() {
        let model = SPFTransformer::new(small_config(), 42);
        let prompt = vec![BOS_ID, 10, 20];
        let generated = model.generate(&prompt, 10, 1.0, 42).unwrap();
        assert!(generated.len() >= prompt.len());
        assert!(generated.len() <= prompt.len() + 10 + 1); // +1 for potential EOS
    }

    #[test]
    fn test_generate_greedy() {
        let model = SPFTransformer::new(small_config(), 42);
        let prompt = vec![BOS_ID, 10];
        // temperature=0 → greedy/argmax — deterministic
        let gen1 = model.generate(&prompt, 5, 0.0, 0).unwrap();
        let gen2 = model.generate(&prompt, 5, 0.0, 0).unwrap();
        assert_eq!(gen1, gen2);
    }

    #[test]
    fn test_num_params_small() {
        let config = small_config();
        let model = SPFTransformer::new(config.clone(), 42);
        let actual = model.num_params();
        let estimated = config.estimate_params();
        // Should be close (estimate might not be exact due to rounding)
        let diff = (actual as f64 - estimated as f64).abs() / actual as f64;
        assert!(diff < 0.05, "Param count mismatch: actual={}, estimated={}", actual, estimated);
    }

    #[test]
    fn test_num_params_writer() {
        let config = TransformerModelConfig::spf_writer();
        let estimated = config.estimate_params();
        // Should be roughly 5M for Writer config
        assert!(estimated > 3_000_000, "Writer should have >3M params, got {}", estimated);
        assert!(estimated < 10_000_000, "Writer should have <10M params, got {}", estimated);
    }

    #[test]
    fn test_invalid_token_id() {
        let config = small_config(); // vocab=512
        let model = SPFTransformer::new(config, 42);
        let ids: Vec<u32> = vec![999]; // exceeds vocab
        assert!(model.forward_causal(&ids, 1, 1).is_err());
    }

    #[test]
    fn test_batch_mismatch() {
        let model = SPFTransformer::new(small_config(), 42);
        let enc = vec![1, 2, 3];
        let dec = vec![1, 2];
        assert!(model.forward(&enc, 1, 3, &dec, 2, 1).is_err()); // batch mismatch
    }

    #[test]
    fn test_weights_collection() {
        let model = SPFTransformer::new(small_config(), 42);
        let weights = model.weights();
        // Should have: 1 embedding + encoder weights + decoder weights + 2 output
        assert!(weights.len() > 30, "Expected many weights, got {}", weights.len());
    }
}