//! Project, Bank, Pattern, and Step structs with serialization.

use std::path::PathBuf;

use serde::{Deserialize, Deserializer, Serialize, Serializer};

use crate::{DEFAULT_LENGTH, MAX_BANKS, MAX_PATTERNS, MAX_STEPS};

/// Speed multiplier for a pattern, expressed as a rational fraction.
#[derive(Clone, Copy, PartialEq, Eq)]
pub struct PatternSpeed {
    pub num: u8,
    pub denom: u8,
}

impl PatternSpeed {
    pub const EIGHTH: Self = Self { num: 1, denom: 8 };
    pub const FIFTH: Self = Self { num: 1, denom: 5 };
    pub const QUARTER: Self = Self { num: 1, denom: 4 };
    pub const THIRD: Self = Self { num: 1, denom: 3 };
    pub const HALF: Self = Self { num: 1, denom: 2 };
    pub const TWO_THIRDS: Self = Self { num: 2, denom: 3 };
    pub const NORMAL: Self = Self { num: 1, denom: 1 };
    pub const DOUBLE: Self = Self { num: 2, denom: 1 };
    pub const QUAD: Self = Self { num: 4, denom: 1 };
    pub const OCTO: Self = Self { num: 8, denom: 1 };

    const PRESETS: &[Self] = &[
        Self::EIGHTH,
        Self::FIFTH,
        Self::QUARTER,
        Self::THIRD,
        Self::HALF,
        Self::TWO_THIRDS,
        Self::NORMAL,
        Self::DOUBLE,
        Self::QUAD,
        Self::OCTO,
    ];

    /// Return the speed as a floating-point multiplier.
    pub fn multiplier(&self) -> f64 {
        self.num as f64 / self.denom as f64
    }

    /// Format as a human-readable label (e.g. "2x", "1/4x").
    pub fn label(&self) -> String {
        if self.denom == 1 {
            format!("{}x", self.num)
        } else {
            format!("{}/{}x", self.num, self.denom)
        }
    }

    /// Return the next faster preset, or self if already at maximum.
    pub fn next(&self) -> Self {
        let current = self.multiplier();
        Self::PRESETS
            .iter()
            .find(|p| p.multiplier() > current + 0.0001)
            .copied()
            .unwrap_or(*self)
    }

    /// Return the next slower preset, or self if already at minimum.
    pub fn prev(&self) -> Self {
        let current = self.multiplier();
        Self::PRESETS
            .iter()
            .rev()
            .find(|p| p.multiplier() < current - 0.0001)
            .copied()
            .unwrap_or(*self)
    }

    /// Parse a speed label like "2x" or "1/4x" into a `PatternSpeed`.
    pub fn from_label(s: &str) -> Option<Self> {
        let s = s.trim().trim_end_matches('x');
        if let Some((num, denom)) = s.split_once('/') {
            let num: u8 = num.parse().ok()?;
            let denom: u8 = denom.parse().ok()?;
            if denom == 0 {
                return None;
            }
            return Some(Self { num, denom });
        }
        if let Ok(val) = s.parse::<f64>() {
            if val <= 0.0 || val > 255.0 {
                return None;
            }
            if (val - val.round()).abs() < 0.0001 {
                return Some(Self {
                    num: val.round() as u8,
                    denom: 1,
                });
            }
            for denom in 1..=16u8 {
                let num = val * denom as f64;
                if (num - num.round()).abs() < 0.0001 && (1.0..=255.0).contains(&num) {
                    return Some(Self {
                        num: num.round() as u8,
                        denom,
                    });
                }
            }
        }
        None
    }
}

impl Default for PatternSpeed {
    fn default() -> Self {
        Self::NORMAL
    }
}

impl Serialize for PatternSpeed {
    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        (self.num, self.denom).serialize(serializer)
    }
}

impl<'de> Deserialize<'de> for PatternSpeed {
    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(untagged)]
        enum SpeedFormat {
            Tuple((u8, u8)),
            Legacy(String),
        }

        match SpeedFormat::deserialize(deserializer)? {
            SpeedFormat::Tuple((num, denom)) => Ok(Self { num, denom }),
            SpeedFormat::Legacy(s) => Ok(match s.as_str() {
                "Eighth" => Self::EIGHTH,
                "Quarter" => Self::QUARTER,
                "Half" => Self::HALF,
                "Normal" => Self::NORMAL,
                "Double" => Self::DOUBLE,
                "Quad" => Self::QUAD,
                "Octo" => Self::OCTO,
                _ => Self::NORMAL,
            }),
        }
    }
}

/// Quantization grid for launching patterns.
#[derive(Clone, Copy, Serialize, Deserialize, Default, PartialEq, Eq)]
pub enum LaunchQuantization {
    Immediate,
    Beat,
    #[default]
    Bar,
    Bars2,
    Bars4,
    Bars8,
}

impl LaunchQuantization {
    /// Human-readable label for display.
    pub fn label(&self) -> &'static str {
        match self {
            Self::Immediate => "Immediate",
            Self::Beat => "Beat",
            Self::Bar => "1 Bar",
            Self::Bars2 => "2 Bars",
            Self::Bars4 => "4 Bars",
            Self::Bars8 => "8 Bars",
        }
    }

    pub fn short_label(&self) -> &'static str {
        match self {
            Self::Immediate => "Imm",
            Self::Beat => "Bt",
            Self::Bar => "1B",
            Self::Bars2 => "2B",
            Self::Bars4 => "4B",
            Self::Bars8 => "8B",
        }
    }

    /// Cycle to the next longer quantization, clamped at `Bars8`.
    pub fn next(&self) -> Self {
        match self {
            Self::Immediate => Self::Beat,
            Self::Beat => Self::Bar,
            Self::Bar => Self::Bars2,
            Self::Bars2 => Self::Bars4,
            Self::Bars4 => Self::Bars8,
            Self::Bars8 => Self::Bars8,
        }
    }

    /// Cycle to the next shorter quantization, clamped at `Immediate`.
    pub fn prev(&self) -> Self {
        match self {
            Self::Immediate => Self::Immediate,
            Self::Beat => Self::Immediate,
            Self::Bar => Self::Beat,
            Self::Bars2 => Self::Bar,
            Self::Bars4 => Self::Bars2,
            Self::Bars8 => Self::Bars4,
        }
    }
}

/// How a pattern synchronizes when launched: restart or phase-lock.
#[derive(Clone, Copy, Serialize, Deserialize, Default, PartialEq, Eq)]
pub enum SyncMode {
    #[default]
    Reset,
    PhaseLock,
}

impl SyncMode {
    /// Human-readable label for display.
    pub fn label(&self) -> &'static str {
        match self {
            Self::Reset => "Reset",
            Self::PhaseLock => "Phase-Lock",
        }
    }

    pub fn short_label(&self) -> &'static str {
        match self {
            Self::Reset => "Rst",
            Self::PhaseLock => "Plk",
        }
    }

    /// Toggle between Reset and PhaseLock.
    pub fn toggle(&self) -> Self {
        match self {
            Self::Reset => Self::PhaseLock,
            Self::PhaseLock => Self::Reset,
        }
    }
}

/// What happens when a pattern finishes: loop, stop, or chain to another.
#[derive(Clone, Copy, Serialize, Deserialize, Default, PartialEq, Eq)]
pub enum FollowUp {
    #[default]
    Loop,
    Stop,
    Chain { bank: usize, pattern: usize },
}

impl FollowUp {
    /// Human-readable label for display.
    pub fn label(&self) -> &'static str {
        match self {
            Self::Loop => "Loop",
            Self::Stop => "Stop",
            Self::Chain { .. } => "Chain",
        }
    }

    /// Cycle forward through follow-up modes.
    pub fn next_mode(&self) -> Self {
        match self {
            Self::Loop => Self::Stop,
            Self::Stop => Self::Chain { bank: 0, pattern: 0 },
            Self::Chain { .. } => Self::Loop,
        }
    }

    /// Cycle backward through follow-up modes.
    pub fn prev_mode(&self) -> Self {
        match self {
            Self::Loop => Self::Chain { bank: 0, pattern: 0 },
            Self::Stop => Self::Loop,
            Self::Chain { .. } => Self::Stop,
        }
    }
}

fn is_default_follow_up(f: &FollowUp) -> bool {
    *f == FollowUp::default()
}

/// Single step in a pattern, holding a Forth script and optional metadata.
#[derive(Clone, Serialize, Deserialize)]
pub struct Step {
    pub active: bool,
    pub script: String,
    #[serde(default)]
    pub source: Option<u8>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
}

impl Step {
    /// True if all fields are at their default values.
    pub fn is_default(&self) -> bool {
        self.active && self.script.is_empty() && self.source.is_none() && self.name.is_none()
    }

    /// True if the script is non-empty.
    pub fn has_content(&self) -> bool {
        !self.script.is_empty()
    }
}

impl Default for Step {
    fn default() -> Self {
        Self {
            active: true,
            script: String::new(),
            source: None,
            name: None,
        }
    }
}

/// Sequence of steps with playback settings (speed, quantization, sync, follow-up).
#[derive(Clone)]
pub struct Pattern {
    pub steps: Vec<Step>,
    pub length: usize,
    pub speed: PatternSpeed,
    pub name: Option<String>,
    pub description: Option<String>,
    pub quantization: LaunchQuantization,
    pub sync_mode: SyncMode,
    pub follow_up: FollowUp,
}

#[derive(Serialize, Deserialize)]
struct SparseStep {
    i: usize,
    #[serde(default = "default_active", skip_serializing_if = "is_true")]
    active: bool,
    #[serde(default, skip_serializing_if = "String::is_empty")]
    script: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    source: Option<u8>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    name: Option<String>,
}

fn default_active() -> bool {
    true
}

fn is_true(v: &bool) -> bool {
    *v
}

#[derive(Serialize, Deserialize)]
struct SparsePattern {
    steps: Vec<SparseStep>,
    length: usize,
    #[serde(default)]
    speed: PatternSpeed,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    description: Option<String>,
    #[serde(default, skip_serializing_if = "is_default_quantization")]
    quantization: LaunchQuantization,
    #[serde(default, skip_serializing_if = "is_default_sync_mode")]
    sync_mode: SyncMode,
    #[serde(default, skip_serializing_if = "is_default_follow_up")]
    follow_up: FollowUp,
}

fn is_default_quantization(q: &LaunchQuantization) -> bool {
    *q == LaunchQuantization::default()
}

fn is_default_sync_mode(s: &SyncMode) -> bool {
    *s == SyncMode::default()
}

#[derive(Deserialize)]
struct LegacyPattern {
    steps: Vec<Step>,
    length: usize,
    #[serde(default)]
    speed: PatternSpeed,
    #[serde(default)]
    name: Option<String>,
    #[serde(default)]
    description: Option<String>,
    #[serde(default)]
    quantization: LaunchQuantization,
    #[serde(default)]
    sync_mode: SyncMode,
    #[serde(default)]
    follow_up: FollowUp,
}

impl Serialize for Pattern {
    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        let sparse_steps: Vec<SparseStep> = self
            .steps
            .iter()
            .enumerate()
            .filter(|(_, step)| !step.is_default())
            .map(|(i, step)| SparseStep {
                i,
                active: step.active,
                script: step.script.clone(),
                source: step.source,
                name: step.name.clone(),
            })
            .collect();

        let sparse = SparsePattern {
            steps: sparse_steps,
            length: self.length,
            speed: self.speed,
            name: self.name.clone(),
            description: self.description.clone(),
            quantization: self.quantization,
            sync_mode: self.sync_mode,
            follow_up: self.follow_up,
        };
        sparse.serialize(serializer)
    }
}

impl<'de> Deserialize<'de> for Pattern {
    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(untagged)]
        enum PatternFormat {
            Sparse(SparsePattern),
            Legacy(LegacyPattern),
        }

        match PatternFormat::deserialize(deserializer)? {
            PatternFormat::Sparse(sparse) => {
                let mut steps: Vec<Step> = (0..MAX_STEPS).map(|_| Step::default()).collect();
                for ss in sparse.steps {
                    if ss.i < MAX_STEPS {
                        steps[ss.i] = Step {
                            active: ss.active,
                            script: ss.script,
                            source: ss.source,
                            name: ss.name,
                        };
                    }
                }
                Ok(Pattern {
                    steps,
                    length: sparse.length,
                    speed: sparse.speed,
                    name: sparse.name,
                    description: sparse.description,
                    quantization: sparse.quantization,
                    sync_mode: sparse.sync_mode,
                    follow_up: sparse.follow_up,
                })
            }
            PatternFormat::Legacy(legacy) => Ok(Pattern {
                steps: legacy.steps,
                length: legacy.length,
                speed: legacy.speed,
                name: legacy.name,
                description: legacy.description,
                quantization: legacy.quantization,
                sync_mode: legacy.sync_mode,
                follow_up: legacy.follow_up,
            }),
        }
    }
}

impl Default for Pattern {
    fn default() -> Self {
        Self {
            steps: (0..MAX_STEPS).map(|_| Step::default()).collect(),
            length: DEFAULT_LENGTH,
            speed: PatternSpeed::default(),
            name: None,
            description: None,
            quantization: LaunchQuantization::default(),
            sync_mode: SyncMode::default(),
            follow_up: FollowUp::default(),
        }
    }
}

impl Pattern {
    /// Borrow a step by index.
    pub fn step(&self, index: usize) -> Option<&Step> {
        self.steps.get(index)
    }

    /// Mutably borrow a step by index.
    pub fn step_mut(&mut self, index: usize) -> Option<&mut Step> {
        self.steps.get_mut(index)
    }

    /// Set the active length, clamped to `[1, MAX_STEPS]`.
    pub fn set_length(&mut self, length: usize) {
        let length = length.clamp(1, MAX_STEPS);
        while self.steps.len() < length {
            self.steps.push(Step::default());
        }
        self.length = length;
    }

    /// Follow the source chain from `index` to find the originating step.
    pub fn resolve_source(&self, index: usize) -> usize {
        let mut current = index;
        for _ in 0..self.steps.len() {
            if let Some(step) = self.steps.get(current) {
                if let Some(source) = step.source {
                    current = source as usize;
                } else {
                    return current;
                }
            } else {
                return index;
            }
        }
        index
    }

    /// Return the script at the resolved source of `index`.
    pub fn resolve_script(&self, index: usize) -> Option<&str> {
        let source_idx = self.resolve_source(index);
        self.steps.get(source_idx).map(|s| s.script.as_str())
    }

    /// Count active-length steps that have a script or a source reference.
    pub fn content_step_count(&self) -> usize {
        self.steps[..self.length]
            .iter()
            .filter(|s| s.has_content() || s.source.is_some())
            .count()
    }
}

/// Collection of patterns forming a bank.
#[derive(Clone, Serialize, Deserialize)]
pub struct Bank {
    pub patterns: Vec<Pattern>,
    #[serde(default)]
    pub name: Option<String>,
}

impl Bank {
    /// Count patterns that contain at least one non-empty step.
    pub fn content_pattern_count(&self) -> usize {
        self.patterns
            .iter()
            .filter(|p| p.content_step_count() > 0)
            .count()
    }
}

impl Default for Bank {
    fn default() -> Self {
        Self {
            patterns: (0..MAX_PATTERNS).map(|_| Pattern::default()).collect(),
            name: None,
        }
    }
}

/// Top-level project: banks, tempo, sample paths, and prelude script.
#[derive(Clone, Serialize, Deserialize)]
pub struct Project {
    pub banks: Vec<Bank>,
    #[serde(default)]
    pub sample_paths: Vec<PathBuf>,
    #[serde(default = "default_tempo")]
    pub tempo: f64,
    #[serde(default)]
    pub playing_patterns: Vec<(usize, usize)>,
    #[serde(default)]
    pub prelude: String,
    #[serde(default)]
    pub script: String,
    #[serde(default)]
    pub script_speed: PatternSpeed,
    #[serde(default = "default_script_length")]
    pub script_length: usize,
}

fn default_tempo() -> f64 {
    120.0
}

fn default_script_length() -> usize {
    16
}

impl Default for Project {
    fn default() -> Self {
        Self {
            banks: (0..MAX_BANKS).map(|_| Bank::default()).collect(),
            sample_paths: Vec::new(),
            tempo: default_tempo(),
            playing_patterns: Vec::new(),
            prelude: String::new(),
            script: String::new(),
            script_speed: PatternSpeed::default(),
            script_length: default_script_length(),
        }
    }
}

impl Project {
    /// Borrow a pattern by bank and pattern index.
    pub fn pattern_at(&self, bank: usize, pattern: usize) -> &Pattern {
        &self.banks[bank].patterns[pattern]
    }

    /// Mutably borrow a pattern by bank and pattern index.
    pub fn pattern_at_mut(&mut self, bank: usize, pattern: usize) -> &mut Pattern {
        &mut self.banks[bank].patterns[pattern]
    }

    /// Pad banks, patterns, and steps to their maximum sizes after deserialization.
    pub fn normalize(&mut self) {
        self.banks.resize_with(MAX_BANKS, Bank::default);
        for bank in &mut self.banks {
            bank.patterns.resize_with(MAX_PATTERNS, Pattern::default);
            for pattern in &mut bank.patterns {
                pattern.steps.resize_with(MAX_STEPS, Step::default);
            }
        }
    }
}