use rustv::isa;
use rustv::memory::{MemoryInterface, Result, SharedMemory};

/// A cache that can be used as two separate caches or one
/// set-associative cache.
pub struct ShareableCache<'a> {
    core_id: usize,
    primary: SharedMemory<'a>,
    secondary: SharedMemory<'a>,
    secondary_enabled: bool,
    use_secondary: bool,
}

impl<'a> ShareableCache<'a> {
    pub fn new(core_id: usize,
               cache1: SharedMemory<'a>, cache2: SharedMemory<'a>)
               -> ShareableCache<'a> {
        ShareableCache {
            core_id: core_id,
            primary: cache1.clone(),
            secondary: cache2.clone(),
            secondary_enabled: false,
            use_secondary: false,
        }
    }

    pub fn enable_secondary(&mut self) {
        self.secondary_enabled = true;
        self.use_secondary = true;
    }

    pub fn disable_secondary(&mut self) {
        self.secondary_enabled = false;
    }

    fn address_accessible(&self, address: isa::Address) -> (bool, bool) {
        // Use scopes to make sure these borrows end before the
        // branches of the if statement begin
        let primary_accessible = {
            self.primary.borrow().is_address_accessible(address)
        };
        let secondary_accessible = {
            self.secondary.borrow().is_address_accessible(address)
        };

        (primary_accessible, secondary_accessible)
    }

    fn snoop(cache: &mut SharedMemory<'a>,
             address: isa::Address, value: isa::Word) {
        // Cache snooping: update all cache lines when a write is made
        if cache.borrow().is_address_accessible(address) {
            // Depends on invariant: write_word completes instantly
            // when the address is accessible (in-cache)
            let _ = cache.borrow_mut().write_word(address, value);
        }
    }
}

impl<'a> MemoryInterface for ShareableCache<'a> {
    fn latency(&self) -> u32 {
        self.primary.borrow().latency()
    }

    fn step(&mut self) {
        // We only step the primary cache. The idea is that the
        // secondary cache should be the primary cache of another
        // ShareableCache.
        self.primary.borrow_mut().step();
    }

    fn is_address_accessible(&self, address: isa::Address) -> bool {
        self.primary.borrow().is_address_accessible(address) ||
            (self.secondary_enabled &&
             self.secondary.borrow().is_address_accessible(address))
    }

    fn read_word(&mut self, address: isa::Address) -> Result<isa::Word> {
        // TODO: disallow access to high or low memory unless
        // secondary cache is enabled. Remember: addresses are already
        // translated

        // TODO: is CacheRacer physically or virtually addressed?
        if self.secondary_enabled {
            let (primary_accessible, secondary_accessible) =
                self.address_accessible(address);

            if primary_accessible {
                self.primary.borrow_mut().read_word(address)
            }
            else if secondary_accessible {
                self.secondary.borrow_mut().read_word(address)
            }
            else {
                self.use_secondary = !self.use_secondary;
                if self.use_secondary {
                    self.secondary.borrow_mut().read_word(address)
                }
                else {
                    self.primary.borrow_mut().read_word(address)
                }
            }
        }
        else {
            self.primary.borrow_mut().read_word(address)
        }
    }

    fn write_word(&mut self, address: isa::Address, value: isa::Word) -> Result<()> {
        if self.secondary_enabled {
            let (primary_accessible, secondary_accessible) =
                self.address_accessible(address);

            if primary_accessible {
                ShareableCache::snoop(&mut self.secondary, address, value);
                self.primary.borrow_mut().write_word(address, value)
            }
            else if secondary_accessible {
                ShareableCache::snoop(&mut self.primary, address, value);
                self.secondary.borrow_mut().write_word(address, value)
            }
            else {
                self.use_secondary = !self.use_secondary;
                if self.use_secondary {
                    ShareableCache::snoop(&mut self.primary, address, value);
                    self.secondary.borrow_mut().write_word(address, value)
                }
                else {
                    ShareableCache::snoop(&mut self.secondary, address, value);
                    self.primary.borrow_mut().write_word(address, value)
                }
            }
        }
        else {
            ShareableCache::snoop(&mut self.secondary, address, value);
            self.primary.borrow_mut().write_word(address, value)
        }
    }
}