#![no_std]
#![allow(dead_code)]
#![allow(unused)]
#![allow(non_upper_case_globals)]
#![warn(missing_docs)]

//! GBA Memory-mapped IO (MMIO) stuff.
//!
//! The GBA is controlled via MMIO. An MMIO location is called a "register",
//! similar to the CPU having registers. The different registers are all
//! globally accessible, so user code must have its own convention for who is
//! supposed to touch what values when.
//!
//! This crate defines newtypes that describe the data layout of each register,
//! and if you enable the `unsafe_addresses` feature it also defines the
//! addresses of each register. The address type used for each register lets you
//! know about the safety (or not) of accessing a given register. The safety
//! assessment relies on the code being run only on a GBA, so if you use this
//! crate on your desktop or something that's your fault.
//!
//! This is only "work in progress" status, but please [file an
//! issue](https://github.com/Lokathor/rubidium/issues) if things are unclear.
//! While you're waiting you can also check
//! [GBATEK](https://problemkaputt.de/gbatek.htm), which is the standard
//! resource for GBA info (and it's most of where this crate's docs come from).
//!
//! ## Naming Conventions
//!
//! The names used for the address of each register is generally the same as, or
//! close to, the the name given for that register in GBATEK.
//!
//! For each setting within a register data newtype there will be three methods
//! per setting contained within the newtype:
//! * A const "getter" named the same as the setting (eg: `foo`).
//! * A const "with-er" which takes `self` and returns a new value (eg:
//!   `with_foo`).
//! * A "setter" which takes `&mut self` and updates the value in place (eg:
//!   `set_foo`). This will hopefully also be const in a future version of Rust.

macro_rules! pub_const_fn_new_zero {
  () => {
    pub const fn new() -> Self {
      Self(0)
    }
  };
}

//

#[rustfmt::skip]
macro_rules! bit {
   (0) => { 0b1 };
   (1) => { 0b10 };
   (2) => { 0b100 };
   (3) => { 0b1000 };
   (4) => { 0b1_0000 };
   (5) => { 0b10_0000 };
   (6) => { 0b100_0000 };
   (7) => { 0b1000_0000 };
   (8) => { 0b1_0000_0000 };
   (9) => { 0b10_0000_0000 };
  (10) => { 0b100_0000_0000 };
  (11) => { 0b1000_0000_0000 };
  (12) => { 0b1_0000_0000_0000 };
  (13) => { 0b10_0000_0000_0000 };
  (14) => { 0b100_0000_0000_0000 };
  (15) => { 0b1000_0000_0000_0000 };
}

macro_rules! bool_bit_u16 {
  ($bit:tt, $get:ident, $with:ident, $set:ident) => {
    #[must_use]
    #[inline(always)]
    #[allow(missing_docs)]
    pub const fn $get(self) -> bool {
      any_in_mask(self.0 as u32, bit!($bit))
    }
    #[must_use]
    #[inline(always)]
    #[allow(missing_docs)]
    pub const fn $with(self, b: bool) -> Self {
      Self(force_mask_bits(self.0 as u32, bit!($bit), b) as u16)
    }
    #[must_use]
    #[inline(always)]
    #[allow(missing_docs)]
    pub fn $set(&mut self, b: bool) {
      *self = self.$with(b);
    }
  };
}

macro_rules! const_enum_bits_u16 {
  ($the_type:tt, $mask:literal, $get:ident, $with:ident, $set:ident) => {
    #[must_use]
    #[inline(always)]
    pub const fn $get(self) -> $the_type {
      $the_type(self.0 & $mask)
    }
    #[must_use]
    #[inline(always)]
    pub const fn $with(self, t: $the_type) -> Self {
      Self(merge_mask_bits(self.0 as u32, t.0 as u32, $mask) as u16)
    }
    #[must_use]
    #[inline(always)]
    pub fn $set(&mut self, t: $the_type) {
      *self = self.$with(t);
    }
  };
}

macro_rules! unsigned_bits_u16 {
  ($low_bit:literal ..= $high_bit:literal, $get:ident, $with:ident, $set:ident) => {
    #[must_use]
    #[inline(always)]
    pub const fn $get(self) -> u16 {
      const MASK: u32 = (0b1 << ($high_bit - $low_bit + 1)) - 1;
      const SHIFT: u32 = u16::trailing_zeros(MASK as u16);
      const BASE_MASK: u32 = (MASK >> SHIFT) as u32;
      ((self.0 as u32 >> SHIFT) & BASE_MASK) as u16
    }
    #[must_use]
    #[inline(always)]
    pub const fn $with(self, u: u16) -> Self {
      const MASK: u32 = (0b1 << ($high_bit - $low_bit + 1)) - 1;
      const SHIFT: u32 = u16::trailing_zeros(MASK as u16);
      const BASE_MASK: u32 = MASK >> SHIFT;
      let bits = (u as u32 & BASE_MASK) << SHIFT;
      Self(merge_mask_bits(self.0 as u32, bits, MASK) as u16)
    }
    #[must_use]
    #[inline(always)]
    pub fn $set(&mut self, u: u16) {
      *self = self.$with(u);
    }
  };
}

//

#[rustfmt::skip]
macro_rules! bit32 {
   (0) => { 0b1 };
   (1) => { 0b10 };
   (2) => { 0b100 };
   (3) => { 0b1000 };
   (4) => { 0b1_0000 };
   (5) => { 0b10_0000 };
   (6) => { 0b100_0000 };
   (7) => { 0b1000_0000 };
   (8) => { 0b1_0000_0000 };
   (9) => { 0b10_0000_0000 };
  (10) => { 0b100_0000_0000 };
  (11) => { 0b1000_0000_0000 };
  (12) => { 0b1_0000_0000_0000 };
  (13) => { 0b10_0000_0000_0000 };
  (14) => { 0b100_0000_0000_0000 };
  (15) => { 0b1000_0000_0000_0000 };
  (16) => { 0b1_0000_0000_0000_0000 };
  (17) => { 0b10_0000_0000_0000_0000 };
  (18) => { 0b100_0000_0000_0000_0000 };
  (19) => { 0b1000_0000_0000_0000_0000 };
  (20) => { 0b1_0000_0000_0000_0000_0000 };
  (21) => { 0b10_0000_0000_0000_0000_0000 };
  (22) => { 0b100_0000_0000_0000_0000_0000 };
  (23) => { 0b1000_0000_0000_0000_0000_0000 };
  (24) => { 0b1_0000_0000_0000_0000_0000_0000 };
  (25) => { 0b10_0000_0000_0000_0000_0000_0000 };
  (26) => { 0b100_0000_0000_0000_0000_0000_0000 };
  (27) => { 0b1000_0000_0000_0000_0000_0000_0000 };
  (28) => { 0b1_0000_0000_0000_0000_0000_0000_0000 };
  (29) => { 0b10_0000_0000_0000_0000_0000_0000_0000 };
  (30) => { 0b100_0000_0000_0000_0000_0000_0000_0000 };
  (31) => { 0b1000_0000_0000_0000_0000_0000_0000_0000 };
}

macro_rules! bool_bit_u32 {
  ($bit:tt, $get:ident, $with:ident, $set:ident) => {
    #[must_use]
    #[inline(always)]
    #[allow(missing_docs)]
    pub const fn $get(self) -> bool {
      any_in_mask(self.0, bit32!($bit))
    }
    #[must_use]
    #[inline(always)]
    #[allow(missing_docs)]
    pub const fn $with(self, b: bool) -> Self {
      Self(force_mask_bits(self.0, bit32!($bit), b))
    }
    #[must_use]
    #[inline(always)]
    #[allow(missing_docs)]
    pub fn $set(&mut self, b: bool) {
      *self = self.$with(b);
    }
  };
}

macro_rules! unsigned_bits_u32 {
  ($low_bit:literal ..= $high_bit:literal, $get:ident, $with:ident, $set:ident) => {
    #[must_use]
    #[inline(always)]
    pub const fn $get(self) -> u32 {
      const MASK: u32 = (0b1 << ($high_bit - $low_bit + 1)) - 1;
      const SHIFT: u32 = u32::trailing_zeros(MASK);
      const BASE_MASK: u32 = (MASK >> SHIFT);
      ((self.0 >> SHIFT) & BASE_MASK)
    }
    #[must_use]
    #[inline(always)]
    pub const fn $with(self, u: u32) -> Self {
      const MASK: u32 = (0b1 << ($high_bit - $low_bit + 1)) - 1;
      const SHIFT: u32 = u32::trailing_zeros(MASK);
      const BASE_MASK: u32 = MASK >> SHIFT;
      let bits = (u & BASE_MASK) << SHIFT;
      Self(merge_mask_bits(self.0, bits, MASK))
    }
    #[must_use]
    #[inline(always)]
    pub fn $set(&mut self, u: u32) {
      *self = self.$with(u);
    }
  };
}

//

macro_rules! submodule {
  ($v:vis $name:ident) => {
    mod $name;
    $v use $name::*;
  };
  ($v:vis $name:ident { $($content:tt)* }) => {
    mod $name { $($content)* }
    $v use $name::*;
  };
}

submodule!(pub video {
  use super::*;

  submodule!(pub bg_affine);
  submodule!(pub bg_cnt);
  submodule!(pub bg_ofs);
  submodule!(pub blending);
  submodule!(pub dispcnt);
  submodule!(pub dispstat);
  submodule!(pub mosaic);
  submodule!(pub vcount);
  submodule!(pub video_mode);
  submodule!(pub window);
});

submodule!(pub volatile {
  use super::*;

  use core::{
    marker::PhantomData,
    num::NonZeroUsize,
    ptr::{read_volatile, write_volatile},
  };

  submodule!(pub danger_write_vol_addr);
  submodule!(pub read_only_vol_addr);
  submodule!(pub simple_vol_addr);
  submodule!(pub write_only_vol_addr);
});

/// Returns `true` if any bits within the mask bits are active.
#[must_use]
#[inline(always)]
pub(crate) const fn any_in_mask(val: u32, mask: u32) -> bool {
  val & mask > 0
}

/// Forces all bits within the mask to be the bool given.
#[must_use]
#[inline(always)]
pub(crate) const fn force_mask_bits(val: u32, mask: u32, b: bool) -> u32 {
  let f = b as u32;
  let neg_f = f.wrapping_neg();
  val ^ ((neg_f ^ val) & mask)
}

/// Merge the bits of two values according to the mask.
#[must_use]
#[inline(always)]
pub(crate) const fn merge_mask_bits(
  not_in_mask: u32,
  in_mask: u32,
  mask: u32,
) -> u32 {
  let a = not_in_mask;
  let b = in_mask;
  a ^ ((a ^ b) & mask)
}