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

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

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

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

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

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

        struct __no_align SampleRate : public IOPort<uint16_t> {
            __io_port_inherit(SampleRate);

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

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

        struct __no_align SweepVolume : public IOPort<int16_t> {
            __io_port_inherit(SweepVolume);

            // For Volume Mode
            static constexpr Bit<int16_t>      ModeBit     = 15; // 0 Volume Mode; 1 Sweep Mode
            static constexpr BitRange<int16_t> VolumeRange = BitRange<int16_t>::from_to(0, 14);

            // For Sweep Mode
            static constexpr Bit<SweepMode>       SweepModeBit      = 14;
            static constexpr Bit<SweepDirection>  SweepDirectionBit = 13;
            static constexpr Bit<SweepPhase>      SweepPhaseBit     = 12;
            static constexpr BitRange<SweepShift> SweepShiftRange   = BitRange<SweepShift>::from_to(2, 6);
            static constexpr BitRange<SweepStep>  SweepStepRange    = BitRange<SweepStep>::from_to(0, 1);
        };

        struct __no_align SR : public IOPort<uint16_t> {
            static constexpr Bit<SweepMode>       SustainModeBit      = (31 - 16);
            static constexpr Bit<SweepDirection>  SustainDirectionBit = (30 - 16);
            static constexpr BitRange<SweepShift> SustainShiftRange   = BitRange<SweepShift>::from_to((24 - 16), (28 - 16));
            static constexpr BitRange<SweepStep>  SustainStepRange    = BitRange<SweepStep>::from_to((22 - 16), (23 - 16));
            static constexpr Bit<SweepMode>       ReleaseModeBit      = (21 - 16);
            static constexpr BitRange<SweepShift> ReleaseShiftRange   = BitRange<SweepShift>::from_to((16 - 16), (20 - 16));
        };

        struct __no_align AD : public IOPort<uint16_t> {
            static constexpr Bit<SweepMode>       AttackModeBit     = 15;
            static constexpr BitRange<SweepShift> AttackShiftRange  = BitRange<SweepShift>::from_to(10, 14);
            static constexpr BitRange<SweepStep>  AttackStepRange   = BitRange<SweepStep>::from_to(8, 9);
            static constexpr BitRange<SweepShift> DecayShiftRange   = BitRange<SweepShift>::from_to(4, 7);
            static constexpr BitRange<uint16_t>   SustainLevelRange = BitRange<uint16_t>::from_to(0, 3);
        };

        struct __no_align Voice {
            SweepVolume         volumeLeft;
            SweepVolume         volumeRight;
            SampleRate          sampleRate;
            IOPort<uint16_t>    adr;
            IOPort<AD>          ad; 
            IOPort<SR>          sr; 
            IOPort<SweepVolume> currentVolume; //Not used
            IOPort<uint16_t>    repeatAdr;
        };

        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);
        }
    }
}

#endif //!__JABYENGINE_SPU_IO_HPP__