#include "main_density.hh"
#include "utils.hh"
#include <functional>
#include "density.hh"

namespace Heck {
    namespace { // anonymous namespace for internal linkage
        // =============================================================================================
        // INIT
        // =============================================================================================
        ld::DaisySeed seed{};

        static ld::MidiUartHandler midi{};

        std::array<float, 4> pots_value{};

        Observer<int> pot1{};
        Observer<int> pot2{};
        Observer<int> pot3{};
        Observer<int> pot4{};

        SWTimer scan_pots{};

        Density density{};

        // function prototypes
        void audio_callback(
            ld::AudioHandle::InputBuffer in,
            ld::AudioHandle::OutputBuffer out,
            size_t size);


        void midi_realtime_handler(const ld::MidiEvent& msg);

        void init()
        {
            seed.Configure();
            seed.Init(Constants::CPU_BOOST480MHZ);
            seed.StartLog(Constants::Developer::LOG_BLOCKS_BOOT);

            {
                ld::AdcChannelConfig adc_cfg[4];
                adc_cfg[0].InitSingle(ld::DaisySeed::GetPin(Constants::Hardware::PIN_POT_1));
                adc_cfg[1].InitSingle(ld::DaisySeed::GetPin(Constants::Hardware::PIN_POT_2));
                adc_cfg[2].InitSingle(ld::DaisySeed::GetPin(Constants::Hardware::PIN_POT_3));
                adc_cfg[3].InitSingle(ld::DaisySeed::GetPin(Constants::Hardware::PIN_POT_4));

                seed.adc.Init(adc_cfg, 4);
                seed.adc.Start();
            }

            seed.PrintLine("Setting Blocksize: %i", Constants::AUDIO_BUFFERSIZE);
            seed.SetAudioBlockSize(Constants::AUDIO_BUFFERSIZE);

            seed.PrintLine("Setting Samplerate: %i", Constants::AUDIO_SAMPLERATE);
            seed.SetAudioSampleRate(Constants::AUDIO_SAMPLERATE);

            seed.PrintLine("Initializing MIDI");
            ld::MidiUartHandler::Config midi_config{};
            midi.Init(midi_config);

            seed.PrintLine("Starting MIDI Receive");
            midi.StartReceiveRt(&midi_realtime_handler);
            midi.Listen();

            seed.PrintLine("Starting Audio");
            seed.StartAudio(audio_callback);
        }


        // =============================================================================================
        // RUN
        // =============================================================================================

        void audio_callback(ld::AudioHandle::InputBuffer in, ld::AudioHandle::OutputBuffer out, size_t size)
        {

            float sig{};
            float sig2{};
            float sig3{};
            // sum to dual mono
//            for (size_t i = 0; i == 0; i++) {
//                sig = in[0][i];
//                sig += in[1][i];

//                sig2 = sig;
                density.process(in[0], out[0], size);

                //                sig *= pots_value

//                out[0][i] = sig3;
//                out[1][i] = sig3;
//            }

            // Channel 1
            //            float sig_out{};
            //            // sum to dual mono
            //            for (size_t i = 0; i < size; i++) {
            //                sig_out = in[0][i];
            //                sig_out += in[1][i];
            //
            //                sig_out *= pot1_value;
            //
            //                out[0][i] = sig_out;
            //                out[1][i] = sig_out;
            //            }
        }


        void midi_realtime_handler(const ld::MidiEvent& msg)
        {
            switch (msg.srt_type) {
                case ld::TimingClock: {
                } break;
                case ld::Start: {
                } break;
                case ld::Stop: {
                } break;
                case ld::Reset: {
                } break;
                case ld::Continue: {
                } break;
            }
        }

        void midi_async_handler(const ld::MidiEvent& msg)
        {
            char strbuf[128];
            GetMidiTypeAsString(msg, &strbuf[0]);
            seed.PrintLine("%s", strbuf);
            return;
        }

        void mainloop()
        {
            seed.PrintLine("Entering MainLoop");
            u32 time_boot_ms{};


            scan_pots.set_period(10);
            scan_pots.set_callback([](u32 time_now) {
                pot1.on_change_fuzzy(seed.adc.Get(0), 10, [](int val) {
                    pots_value[0] = float(val) / (float)std::numeric_limits<u16>::max();
                    density.params[0] =  (pots_value[0] * 5.f) - 1.f;
                    seed.PrintLine("POT_0: %d", (int)(pots_value[0] * 100.));
                });
                pot2.on_change_fuzzy(seed.adc.Get(1), 10, [](int val) {
                    pots_value[1] = float(val) / (float)std::numeric_limits<u16>::max();
                    density.params[1] = pots_value[1];
                    seed.PrintLine("POT_1: %d", (int)(pots_value[1] * 100.));
                });
                pot3.on_change_fuzzy(seed.adc.Get(2), 10, [](int val) {
                    pots_value[2] = float(val) / (float)std::numeric_limits<u16>::max();
                    density.params[2] = pots_value[2];
                    seed.PrintLine("POT_2: %d", (int)(pots_value[2] * 100.));
                });
                pot4.on_change_fuzzy(seed.adc.Get(3), 10, [](int val) {
                    pots_value[3] = float(val) / (float)std::numeric_limits<u16>::max();
                    density.params[3] = pots_value[3];
                    seed.PrintLine("POT_3: %d", (int)(pots_value[3] * 100.));
                });
            });


            bool heartbeat_led_state{ false };

            SWTimer heartbeat{};
            heartbeat.set_period(100);
            heartbeat.set_callback([&heartbeat_led_state](u32 time_now) {
                heartbeat_led_state = !heartbeat_led_state;
                seed.SetLed(heartbeat_led_state);
                return;
            });

            while (true) {
                time_boot_ms = ld::System::GetNow();

                while (midi.HasEvents()) {
                    midi_async_handler(midi.PopEvent());
                }

                scan_pots.is_it_already_time_again(time_boot_ms);
                heartbeat.is_it_already_time_again(time_boot_ms);
            }
        }
    } // namespace
} // namespace Heck


int main()
{
    Heck::init();
    Heck::mainloop();
}