use std::collections::{BTreeMap, BTreeSet};
use std::fs;
use std::path::Path;

use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum BuildingTypeSourceKind {
    Bca,
    Bty,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct BuildingTypeSourceFile {
    pub file_name: String,
    pub raw_stem: String,
    pub canonical_stem: String,
    pub source_kind: BuildingTypeSourceKind,
    #[serde(default)]
    pub byte_len: Option<usize>,
    #[serde(default)]
    pub bca_selector_probe: Option<BuildingTypeBcaSelectorProbe>,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct BuildingTypeSourceEntry {
    pub canonical_stem: String,
    pub raw_stems: Vec<String>,
    pub source_kinds: Vec<BuildingTypeSourceKind>,
    pub file_names: Vec<String>,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct BuildingTypeBcaSelectorProbe {
    pub byte_0xb8: u8,
    pub byte_0xb8_hex: String,
    pub byte_0xb9: u8,
    pub byte_0xb9_hex: String,
    pub byte_0xba: u8,
    pub byte_0xba_hex: String,
    pub byte_0xbb: u8,
    pub byte_0xbb_hex: String,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct BuildingTypeBcaSelectorPatternSummary {
    pub byte_len: usize,
    pub byte_0xb8_hex: String,
    pub byte_0xb9_hex: String,
    pub byte_0xba_hex: String,
    pub byte_0xbb_hex: String,
    pub file_count: usize,
    pub sample_file_names: Vec<String>,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct BuildingTypeNamedBindingComparison {
    pub bindings_path: String,
    pub named_binding_count: usize,
    pub shared_canonical_stem_count: usize,
    pub binding_only_canonical_stems: Vec<String>,
    pub source_only_canonical_stems: Vec<String>,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct BuildingTypeSourceReport {
    pub directory_path: String,
    pub bca_file_count: usize,
    pub bty_file_count: usize,
    pub unique_canonical_stem_count: usize,
    pub bca_selector_pattern_count: usize,
    #[serde(default)]
    pub named_binding_comparison: Option<BuildingTypeNamedBindingComparison>,
    pub notes: Vec<String>,
    pub bca_selector_patterns: Vec<BuildingTypeBcaSelectorPatternSummary>,
    pub files: Vec<BuildingTypeSourceFile>,
    pub entries: Vec<BuildingTypeSourceEntry>,
}

pub fn inspect_building_types_dir(
    path: &Path,
) -> Result<BuildingTypeSourceReport, Box<dyn std::error::Error>> {
    inspect_building_types_dir_with_bindings(path, None)
}

pub fn inspect_building_types_dir_with_bindings(
    path: &Path,
    bindings_path: Option<&Path>,
) -> Result<BuildingTypeSourceReport, Box<dyn std::error::Error>> {
    let mut files = Vec::new();
    for entry in fs::read_dir(path)? {
        let entry = entry?;
        if !entry.file_type()?.is_file() {
            continue;
        }
        let file_name = entry.file_name().to_string_lossy().into_owned();
        let Some(extension) = Path::new(&file_name)
            .extension()
            .and_then(|extension| extension.to_str())
            .map(|extension| extension.to_ascii_lowercase())
        else {
            continue;
        };
        let source_kind = match extension.as_str() {
            "bca" => BuildingTypeSourceKind::Bca,
            "bty" => BuildingTypeSourceKind::Bty,
            _ => continue,
        };
        let bytes = fs::read(entry.path())?;
        let raw_stem = Path::new(&file_name)
            .file_stem()
            .and_then(|stem| stem.to_str())
            .unwrap_or("")
            .to_string();
        if raw_stem.is_empty() {
            continue;
        }
        files.push(BuildingTypeSourceFile {
            file_name,
            canonical_stem: canonicalize_building_stem(&raw_stem),
            raw_stem,
            source_kind: source_kind.clone(),
            byte_len: Some(bytes.len()),
            bca_selector_probe: match source_kind {
                BuildingTypeSourceKind::Bca => Some(probe_bca_selector_bytes(&bytes)),
                BuildingTypeSourceKind::Bty => None,
            },
        });
    }

    files.sort_by(|left, right| {
        left.canonical_stem
            .cmp(&right.canonical_stem)
            .then_with(|| left.file_name.cmp(&right.file_name))
    });

    let mut grouped = BTreeMap::<String, Vec<&BuildingTypeSourceFile>>::new();
    for file in &files {
        grouped
            .entry(file.canonical_stem.clone())
            .or_default()
            .push(file);
    }

    let entries = grouped
        .into_iter()
        .map(|(canonical_stem, group)| BuildingTypeSourceEntry {
            canonical_stem,
            raw_stems: group
                .iter()
                .map(|file| file.raw_stem.clone())
                .collect::<BTreeSet<_>>()
                .into_iter()
                .collect(),
            source_kinds: group
                .iter()
                .map(|file| file.source_kind.clone())
                .collect::<BTreeSet<_>>()
                .into_iter()
                .collect(),
            file_names: group
                .iter()
                .map(|file| file.file_name.clone())
                .collect::<BTreeSet<_>>()
                .into_iter()
                .collect(),
        })
        .collect::<Vec<_>>();

    let bca_file_count = files
        .iter()
        .filter(|file| matches!(file.source_kind, BuildingTypeSourceKind::Bca))
        .count();
    let bty_file_count = files
        .iter()
        .filter(|file| matches!(file.source_kind, BuildingTypeSourceKind::Bty))
        .count();
    let mut grouped_selector_patterns =
        BTreeMap::<(usize, String, String, String, String), Vec<String>>::new();
    for file in &files {
        let Some(probe) = &file.bca_selector_probe else {
            continue;
        };
        grouped_selector_patterns
            .entry((
                file.byte_len.unwrap_or_default(),
                probe.byte_0xb8_hex.clone(),
                probe.byte_0xb9_hex.clone(),
                probe.byte_0xba_hex.clone(),
                probe.byte_0xbb_hex.clone(),
            ))
            .or_default()
            .push(file.file_name.clone());
    }
    let bca_selector_patterns = grouped_selector_patterns
        .into_iter()
        .map(
            |(
                (byte_len, byte_0xb8_hex, byte_0xb9_hex, byte_0xba_hex, byte_0xbb_hex),
                file_names,
            )| BuildingTypeBcaSelectorPatternSummary {
                byte_len,
                byte_0xb8_hex,
                byte_0xb9_hex,
                byte_0xba_hex,
                byte_0xbb_hex,
                file_count: file_names.len(),
                sample_file_names: file_names.into_iter().take(12).collect(),
            },
        )
        .collect::<Vec<_>>();

    let notes = vec![
        "BuildingTypes sources are grouped by a canonical stem that lowercases and strips spaces, underscores, and hyphens so paired .bca/.bty variants collapse onto one asset token.".to_string(),
        "This report is an offline asset-pool view only; it does not by itself assign live candidate ids or prove scenario candidate-table availability.".to_string(),
        "For .bca files, the report also exposes the narrow selector-byte window at offsets 0xb8..0xbb used by the grounded aux-candidate and live-candidate stream decoders.".to_string(),
    ];

    let named_binding_comparison = if let Some(bindings_path) = bindings_path {
        Some(load_named_binding_comparison(bindings_path, &entries)?)
    } else {
        None
    };

    Ok(BuildingTypeSourceReport {
        directory_path: path.display().to_string(),
        bca_file_count,
        bty_file_count,
        unique_canonical_stem_count: entries.len(),
        bca_selector_pattern_count: bca_selector_patterns.len(),
        named_binding_comparison,
        notes,
        bca_selector_patterns,
        files,
        entries,
    })
}

fn probe_bca_selector_bytes(bytes: &[u8]) -> BuildingTypeBcaSelectorProbe {
    let byte_0xb8 = bytes.get(0xb8).copied().unwrap_or(0);
    let byte_0xb9 = bytes.get(0xb9).copied().unwrap_or(0);
    let byte_0xba = bytes.get(0xba).copied().unwrap_or(0);
    let byte_0xbb = bytes.get(0xbb).copied().unwrap_or(0);
    BuildingTypeBcaSelectorProbe {
        byte_0xb8,
        byte_0xb8_hex: format!("0x{byte_0xb8:02x}"),
        byte_0xb9,
        byte_0xb9_hex: format!("0x{byte_0xb9:02x}"),
        byte_0xba,
        byte_0xba_hex: format!("0x{byte_0xba:02x}"),
        byte_0xbb,
        byte_0xbb_hex: format!("0x{byte_0xbb:02x}"),
    }
}

fn load_named_binding_comparison(
    bindings_path: &Path,
    entries: &[BuildingTypeSourceEntry],
) -> Result<BuildingTypeNamedBindingComparison, Box<dyn std::error::Error>> {
    let artifact =
        serde_json::from_str::<BuildingBindingArtifact>(&fs::read_to_string(bindings_path)?)?;
    let named_binding_stems = artifact
        .bindings
        .into_iter()
        .filter_map(|binding| binding.candidate_name)
        .map(|candidate_name| canonicalize_building_stem(&candidate_name))
        .collect::<BTreeSet<_>>();
    let source_stems = entries
        .iter()
        .map(|entry| entry.canonical_stem.clone())
        .collect::<BTreeSet<_>>();

    Ok(BuildingTypeNamedBindingComparison {
        bindings_path: bindings_path.display().to_string(),
        named_binding_count: named_binding_stems.len(),
        shared_canonical_stem_count: named_binding_stems.intersection(&source_stems).count(),
        binding_only_canonical_stems: named_binding_stems
            .difference(&source_stems)
            .cloned()
            .collect(),
        source_only_canonical_stems: source_stems
            .difference(&named_binding_stems)
            .cloned()
            .collect(),
    })
}

fn canonicalize_building_stem(stem: &str) -> String {
    stem.chars()
        .filter(|ch| !matches!(ch, ' ' | '_' | '-'))
        .flat_map(|ch| ch.to_lowercase())
        .collect()
}

#[derive(Debug, Clone, PartialEq, Eq, Deserialize)]
struct BuildingBindingArtifact {
    bindings: Vec<BuildingBindingRow>,
}

#[derive(Debug, Clone, PartialEq, Eq, Deserialize)]
struct BuildingBindingRow {
    #[serde(default)]
    candidate_name: Option<String>,
}

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

    #[test]
    fn probes_bca_selector_bytes_from_fixed_offsets() {
        let mut bytes = vec![0u8; 0xbc + 1];
        bytes[0xb8] = 0x12;
        bytes[0xb9] = 0x34;
        bytes[0xba] = 0x56;
        bytes[0xbb] = 0x78;
        let probe = probe_bca_selector_bytes(&bytes);
        assert_eq!(probe.byte_0xb8, 0x12);
        assert_eq!(probe.byte_0xb9, 0x34);
        assert_eq!(probe.byte_0xba, 0x56);
        assert_eq!(probe.byte_0xbb, 0x78);
        assert_eq!(probe.byte_0xb8_hex, "0x12");
        assert_eq!(probe.byte_0xbb_hex, "0x78");
    }
}
