#ifndef __JABYENGINE_SPU_IO_HPP__
#define __JABYENGINE_SPU_IO_HPP__
#include "IOPort.hpp"
#include <limits.h>

namespace SPU {
    namespace Port {
        enum struct Mode {
            Linear      = 0,
            Exponential = 1,
        };

        enum struct Direction {
            Increase = 0,
            Decrease = 1,
        };

        enum struct Phase {
            Posititve = 0,
            Negative  = 1,
        };

        //0..0x1F = Fast..Slow
        typedef uint8_t Shift;

        //0..3 = +7, +6, +5, +4 or -6, -7, -6, -5
        typedef uint8_t Step;

        struct __no_align SampleRate : public ComplexBitMap<uint16_t> {
            __io_port_inherit_complex_bit_map(SampleRate);

            static constexpr SampleRate from_HZ(double freq) {
                //4096 == 44100Hz
                constexpr double Base = (4096.0 / 44100.0);

                return ComplexBitMap(static_cast<uint16_t>((freq*Base)));
            }
        };

        struct __no_align SweepVolume : public ComplexBitMap<int16_t> {
            __io_port_inherit_complex_bit_map(SweepVolume);

            // For Volume Mode
            static constexpr Bit<int16_t>      SweepEnable  = 15; // 0 Volume Mode; 1 Sweep Mode
            static constexpr auto              VolumeEnable = !SweepEnable;
            static constexpr BitRange<int16_t> Volume       = BitRange<int16_t>::from_to(0, 14);

            // For Sweep Mode
            static constexpr Bit<Mode>       SweepMode      = 14;
            static constexpr Bit<Direction>  SweepDirection = 13;
            static constexpr Bit<Phase>      SweepPhase     = 12;
            static constexpr BitRange<Shift> SweepShift     = BitRange<Shift>::from_to(2, 6);
            static constexpr BitRange<Step>  SweepStep      = BitRange<Step>::from_to(0, 1);
        };

        struct __no_align SR : public ComplexBitMap<uint16_t> {
            __io_port_inherit_complex_bit_map(SR);
            
            static constexpr Bit<Mode>       SustainMode      = (31 - 16);
            static constexpr Bit<Direction>  SustainDirection = (30 - 16);
            static constexpr BitRange<Shift> SustainShift     = BitRange<Shift>::from_to((24 - 16), (28 - 16));
            static constexpr BitRange<Step>  SustainStep      = BitRange<Step>::from_to((22 - 16), (23 - 16));
            static constexpr Bit<Mode>       ReleaseMode      = (21 - 16);
            static constexpr BitRange<Shift> ReleaseShift     = BitRange<Shift>::from_to((16 - 16), (20 - 16));
        };

        struct __no_align AD : public ComplexBitMap<uint16_t> {
            __io_port_inherit_complex_bit_map(AD);

            static constexpr Bit<Mode>          AttackMode   = 15;
            static constexpr BitRange<Shift>    AttackShift  = BitRange<Shift>::from_to(10, 14);
            static constexpr BitRange<Step>     AttackStep   = BitRange<Step>::from_to(8, 9);
            static constexpr BitRange<Shift>    DecayShift   = BitRange<Shift>::from_to(4, 7);
            static constexpr BitRange<uint16_t> SustainLevel = BitRange<uint16_t>::from_to(0, 3);
        };

        struct __no_align Voice {
            IOPort<SweepVolume> volumeLeft;    //Offset: 0x0
            IOPort<SweepVolume> volumeRight;   //Offset: 0x2
            IOPort<SampleRate>  sampleRate;    //Offset: 0x4;
            IOPort<uint16_t>    adr;           //Offset: 0x6
            IOPort<AD>          ad;            //Offset: 0x8
            IOPort<SR>          sr;            //Offset: 0xA
            IOPort<SweepVolume> currentVolume; //Offset: 0xC
            IOPort<uint16_t>    repeatAdr;     //Offset: 0xE
        };

        struct __no_align ControlRegister : public ComplexBitMap<uint16_t> {
            __io_port_inherit_complex_bit_map(ControlRegister);

            enum RAMTransferMode {
                Stop        = 0,
                ManualWrite = 1,
                DMAWrite    = 2,
                DMARead     = 3
            };

            static constexpr Bit<uint16_t>             Enable              = 15;
            static constexpr Bit<uint16_t>             Unmute              = 14;
            static constexpr BitRange<Shift>           NoiseFrequcenyShift = BitRange<Shift>::from_to(10, 13);
            static constexpr BitRange<Step>            NoiseFrequcenyStep  = BitRange<Step>::from_to(8, 9);
            static constexpr Bit<uint16_t>             ReverbMasterEnable  = 7;
            static constexpr Bit<uint16_t>             IRQ9Enable          = 6;
            static constexpr BitRange<RAMTransferMode> TransferMode        = BitRange<RAMTransferMode>::from_to(4, 5);
            static constexpr Bit<uint16_t>             ExternalAudioReverb = 3;
            static constexpr Bit<uint16_t>             CDAudioReverb       = 2;
            static constexpr Bit<uint16_t>             ExternalAudioEnable = 1;
            static constexpr Bit<uint16_t>             CDAudioEnable       = 0;
        };

        struct __no_align PitchModFlags : public ComplexBitMap<uint16_t> {
            __io_port_inherit_complex_bit_map(PitchModFlags);

            static constexpr BitRange<uint16_t> EnableBits = BitRange<uint16_t>::from_to(1, 23);
        };

        struct __no_align NoiseGenerator : public ComplexBitMap<uint16_t> {
            __io_port_inherit_complex_bit_map(NoiseGenerator);

            static constexpr BitRange<uint16_t> NoiseBits = BitRange<uint16_t>::from_to(0, 23);
        };

        struct __no_align EchoOn : public ComplexBitMap<uint16_t> {
            __io_port_inherit_complex_bit_map(EchoOn);

            static constexpr BitRange<uint16_t> EchoBits = BitRange<uint16_t>::from_to(0, 23);
        };

        static constexpr size_t VoiceCount = 24;

        namespace Key {
            __declare_io_port_global(ubus32_t, on,     0x1F801D88);
            __declare_io_port_global(ubus32_t, off,    0x1F801D8C);
            __declare_io_port_global(ubus32_t, status, 0x1F801D9C);
        }

        namespace MainVolume {
            __declare_io_port_global(SweepVolume, left,  0x1F801D80);
            __declare_io_port_global(SweepVolume, right, 0x1F801D82);
        }

        namespace CDVolume {
            __declare_io_port_global(int16_t, left,  0x1F801DB0);
            __declare_io_port_global(int16_t, right, 0x1F801DB2);
        }

        namespace ExternalAudioInputVolume {
            __declare_io_port_global(int16_t, left,  0x1F801DB4);
            __declare_io_port_global(int16_t, right, 0x1F801DB6);
        }

        namespace Reverb {
            namespace Volume {
                __declare_io_port_global(int16_t, left,  0x1F801D84);
                __declare_io_port_global(int16_t, right, 0x1F801D86);
            }
            __declare_io_port_global(uint16_t, work_area_adr, 0x1F801DA2);
        }

        __declare_io_port_global(ControlRegister, Control,             0x1F801DAA);
        __declare_io_port_global(uint16_t,        DataTransferControl, 0x1F801DAC);
        __declare_io_port_global(PitchModFlags,   PMON,                0x1F801D90);
        __declare_io_port_global(NoiseGenerator,  NON,                 0x1F801D94);
        __declare_io_port_global(EchoOn,          EON,                 0x1F801D98);
        
        __declare_io_port_global_array(Voice, Voices, 0x1F801C00, VoiceCount);
    }
}

#endif //!__JABYENGINE_SPU_IO_HPP__