use prometeu_hal::glyph_bank::GlyphBank;
use prometeu_hal::sound_bank::SoundBank;
use std::sync::{Arc, RwLock};

/// Non-generic interface for peripherals to access graphical glyph banks.
pub trait GlyphBankPoolAccess: Send + Sync {
    /// Returns a reference to the resident GlyphBank in the specified slot, if any.
    fn glyph_bank_slot(&self, slot: usize) -> Option<Arc<GlyphBank>>;
    /// Returns the total number of slots available in this bank.
    fn glyph_bank_slot_count(&self) -> usize;
}

/// Non-generic interface for the AssetManager to install graphical glyph banks.
pub trait GlyphBankPoolInstaller: Send + Sync {
    /// Atomically swaps the resident GlyphBank in the specified slot.
    fn install_glyph_bank(&self, slot: usize, bank: Arc<GlyphBank>);
}

/// Non-generic interface for peripherals to access sound banks.
pub trait SoundBankPoolAccess: Send + Sync {
    /// Returns a reference to the resident SoundBank in the specified slot, if any.
    fn sound_bank_slot(&self, slot: usize) -> Option<Arc<SoundBank>>;
    /// Returns the total number of slots available in this bank.
    fn sound_bank_slot_count(&self) -> usize;
}

/// Non-generic interface for the AssetManager to install sound banks.
pub trait SoundBankPoolInstaller: Send + Sync {
    /// Atomically swaps the resident SoundBank in the specified slot.
    fn install_sound_bank(&self, slot: usize, bank: Arc<SoundBank>);
}

/// Centralized container for all hardware memory banks.
///
/// MemoryBanks represent the actual hardware slot state.
/// Peripherals consume this state via narrow, non-generic traits.
/// AssetManager coordinates residency and installs assets into these slots.
pub struct MemoryBanks {
    glyph_bank_pool: Arc<RwLock<[Option<Arc<GlyphBank>>; 16]>>,
    sound_bank_pool: Arc<RwLock<[Option<Arc<SoundBank>>; 16]>>,
}

impl Default for MemoryBanks {
    fn default() -> Self {
        Self::new()
    }
}

impl MemoryBanks {
    /// Creates a new set of memory banks with empty slots.
    pub fn new() -> Self {
        Self {
            glyph_bank_pool: Arc::new(RwLock::new(std::array::from_fn(|_| None))),
            sound_bank_pool: Arc::new(RwLock::new(std::array::from_fn(|_| None))),
        }
    }
}

impl GlyphBankPoolAccess for MemoryBanks {
    fn glyph_bank_slot(&self, slot: usize) -> Option<Arc<GlyphBank>> {
        let pool = self.glyph_bank_pool.read().unwrap();
        pool.get(slot).and_then(|s| s.as_ref().map(Arc::clone))
    }

    fn glyph_bank_slot_count(&self) -> usize {
        16
    }
}

impl GlyphBankPoolInstaller for MemoryBanks {
    fn install_glyph_bank(&self, slot: usize, bank: Arc<GlyphBank>) {
        let mut pool = self.glyph_bank_pool.write().unwrap();
        if slot < 16 {
            pool[slot] = Some(bank);
        }
    }
}

impl SoundBankPoolAccess for MemoryBanks {
    fn sound_bank_slot(&self, slot: usize) -> Option<Arc<SoundBank>> {
        let pool = self.sound_bank_pool.read().unwrap();
        pool.get(slot).and_then(|s| s.as_ref().map(Arc::clone))
    }

    fn sound_bank_slot_count(&self) -> usize {
        16
    }
}

impl SoundBankPoolInstaller for MemoryBanks {
    fn install_sound_bank(&self, slot: usize, bank: Arc<SoundBank>) {
        let mut pool = self.sound_bank_pool.write().unwrap();
        if slot < 16 {
            pool[slot] = Some(bank);
        }
    }
}