#include "zsm_backend.hpp"
#include <algorithm>
extern "C" {
#include "x16emu/glue.h"
#include "x16emu/vera_pcm.h"
#include "x16emu/vera_psg.h"
#include "x16emu/ymglue.h"
}
#include <exception>
#include <filesystem>
#include "file_backend.hpp"
#include <stddef.h>
#include <string.h>
#include <file_backend.hpp>
#define HZ (AUDIO_SAMPLERATE)
#define BUFFERS 32
void ZsmBackend::load(const char *filename) {
	memset(&spec, 0, sizeof(spec));
    spec.format = AUDIO_S16SYS;
    spec.samples = 100;
    spec.channels = 2;
    spec.freq = PSG_FREQ;
    spec.size = 100 * 2 * sizeof(int16_t);
    file = open_file(filename);
    char magic[2];
    file->read(magic, 2, 1);
    if (magic[0] != 0x7a || magic[1] != 0x6d) {
        throw std::exception();
    }
    uint8_t version;
    file->read(&version, 1, 1);
    uint8_t loop_point[3];
    file->read(loop_point, 3, 1);
    this->loop_point = loop_point[0] | ((uint32_t)(loop_point[1]) << 8) | ((uint32_t)(loop_point[2]) << 16);
    file->read(loop_point, 3, 1);
    this->pcm_offset = loop_point[0] | ((uint32_t)(loop_point[1]) << 8) | ((uint32_t)(loop_point[2]) << 16);
    pcm_offset += 3;
    file->read(&fm_mask, 1, 1);
    file->read(loop_point, 2, 1);
    this->psg_channel_mask = loop_point[0] | ((uint16_t)(loop_point[1]) << 8);
    file->read(loop_point, 2, 1);
    this->tick_rate = loop_point[0] | ((uint16_t)(loop_point[1]) << 8);
    file->read(loop_point, 2, 1); // Reserved.
    music_data_start = file->get_pos();
    this->loop_point += music_data_start;
    file->seek(pcm_offset, SeekType::SET);
    file->read(loop_point, 1, 1);
    pcm_offset++;
    pcm_data_offs = ((((uint16_t)loop_point[0]) + 1) * 16) + pcm_offset;
    file->seek(music_data_start, SeekType::SET);
    this->loop_point = std::max(this->loop_point, (uint32_t)music_data_start);
    double prev_time = 0.0;
    double time = 0.0;
    double tmpDelayTicks = 0.0;
    loop_pos = -1.0;
    uint32_t prev_pos = music_data_start;
    while (true) {
        tmpDelayTicks -= get_delay_per_frame();
        if (tmpDelayTicks < 0.0) {
            ZsmCommand cmd = get_command();
            size_t cur_pos = file->get_pos();
            if (cur_pos >= this->loop_point && this->loop_pos < 0) {
            	if (cur_pos > this->loop_point) {
             		this->loop_point = prev_pos;
               		loop_pos = prev_time;
	            } else {
	               	loop_pos = time;
	               	this->loop_point = cur_pos;
	            }
            }
            if (cmd.id == ZsmEOF) {
                break;
            } else if (cmd.id == Delay) {
                time += ((double)cmd.delay) / ((double)(tick_rate));
                tmpDelayTicks += cmd.delay;
            }
            prev_pos = file->get_pos();
            prev_time = time;
        }
    }
    if (this->loop_pos < 0.0) {
    	this->loop_pos = 0.0;
    	this->loop_point = music_data_start;
    }
    length = time;
    music_data_len = file->get_pos();
    switch_stream(0);
    loop_end = length;
    loop_start = this->loop_pos;
    fm_stream = SDL_NewAudioStream(AUDIO_S16SYS, 2, YM_FREQ, AUDIO_S16SYS, 2, PSG_FREQ);
    DEBUG.writefln("fm_stream: %ld -> %ld", YM_FREQ, PSG_FREQ);
}
extern SDL_AudioSpec obtained;
void ZsmBackend::switch_stream(int idx) {
    YM_Create(YM_FREQ);
    YM_init(YM_FREQ/64, 60);
    YM_reset();
    psg_reset();
    pcm_reset();
    for (uint8_t i = 0; i < 16; i++) {
        psg_writereg(i * 4 + 2, 0);
    }
    this->cpuClocks = 0.0;
    this->delayTicks = 0.0;
    this->ticks = 0.0;
}
void ZsmBackend::cleanup() {
    delete file;
    file = nullptr;
    audio_buf.clear();
    SDL_FreeAudioStream(fm_stream);
    fm_stream = nullptr;
}
void ZsmBackend::tick(bool step) {
    delayTicks -= 1;
    const double ClocksPerTick = ((double)HZ) / ((double)tick_rate);
    ssize_t ticks_remaining = ClocksPerTick;
    while (delayTicks <= 0) {
        ZsmCommand cmd = get_command();
        switch (cmd.id) {
            case ZsmEOF: {
                if (step) {
                    file->seek(this->loop_point, SeekType::SET);
                    this->position = loop_pos;
                } else {
                    throw std::exception();
                }
            } break;
            case PsgWrite: {
                psg_writereg(cmd.psg_write.reg, cmd.psg_write.val);
            } break;
            case FmWrite: {
                for (uint8_t i = 0; i < cmd.fm_write.len; i++) {
                    YM_write_reg(cmd.fm_write.regs[i].reg, cmd.fm_write.regs[i].val);
                    while (YM_read_status()) {
                        size_t clocksToAddForYm = 64;
                        ticks_remaining -= clocksToAddForYm;
                        if (ticks_remaining < 0) {
                            delayTicks -= 1;
                            cpuClocks += ClocksPerTick;
                            ticks_remaining += ClocksPerTick;
                        }
                        audio_step(clocksToAddForYm);
                    }
                }
            } break;
            case Delay: {
                delayTicks += cmd.delay;
                position += ((double)cmd.delay) / ((double)(tick_rate));
            } break;
            case ExtCmd: {
                //cmd.extcmd.channel
                switch (cmd.extcmd.channel) {
                    case 0: {
                        for (size_t i = 0; i < cmd.extcmd.bytes; i += 2) {
                            switch (cmd.extcmd.pcm[i]) {
                                case 0: { // ctrl
                                    pcm_write_ctrl(cmd.extcmd.pcm[i + 1]);
                                } break;
                                case 1: { // rate
                                    pcm_write_rate(cmd.extcmd.pcm[i + 1]);
                                } break;
                                default: { // trigger
                                    size_t file_pos = file->get_pos();
                                    uint8_t ctrl = pcm_read_ctrl();
                                    pcm_write_ctrl(ctrl | 0x80);
                                    uint16_t pcm_idx = cmd.extcmd.pcm[i + 1];
                                    uint16_t instdef = pcm_idx * 16;
                                    file->seek(pcm_offset + instdef, SeekType::SET);
                                    uint8_t geom;
                                    file->read(&geom, 1, 1);
                                    ctrl = pcm_read_ctrl() & 0x0F;
                                    ctrl |= geom & 0x30;
                                    pcm_write_ctrl(ctrl);
                                    uint8_t bytes[10];
                                    file->read(bytes, 10, 1);
                                    loop_rem = bytes[9];
                                    loop_rem <<= 8;
                                    loop_rem |= bytes[8];
                                    loop_rem <<= 8;
                                    loop_rem |= bytes[7];
                                    loop = loop_rem;
                                    islooped = bytes[6] & 0x80;
                                    remain = bytes[5];
                                    remain <<= 8;
                                    remain |= bytes[4];
                                    remain <<= 8;
                                    remain |= bytes[3];
                                    cur = bytes[2];
                                    cur <<= 8;
                                    cur |= bytes[1];
                                    cur <<= 8;
                                    cur |= bytes[0];
                                    cur += pcm_data_offs;
                                    loop += cur;
                                    loop_rem = remain - loop_rem;
                                    file->seek(file_pos, SeekType::SET);
                                } break;
                            }
                            //cmd.extcmd.pcm
                            audio_step(0);
                        } break;
                    }
                // Nothing handled yet.
                }
            } break;
        }
    }
    audio_step(ticks_remaining);
    cpuClocks += ClocksPerTick;
}
void ZsmBackend::add_clocks(double amount, bool step) {
    const double ClocksPerTick = ((double)HZ) / ((double)tick_rate);
    cpuClocks = std::fmod(cpuClocks, ClocksPerTick);
    double prevCpuClocks = cpuClocks;
    size_t prevIntCpuClocks = prevCpuClocks;
    double tickDelta = amount / ClocksPerTick;
    double prevTicks = ticks;
    ticks += tickDelta;
    size_t prevIntTicks = prevTicks;
    size_t intTicks = ticks;
    size_t intTicksDelta = intTicks - prevIntTicks;
    cpuClocks += intTicks * ClocksPerTick;
    double remainder = amount - (intTicksDelta * ClocksPerTick);
    size_t intCpuClocks = cpuClocks;
    size_t intCpuClockDelta = intCpuClocks - prevIntCpuClocks;
    double initialTicks = prevCpuClocks / ClocksPerTick;
    for (size_t i = 0; i < intTicksDelta; i++) {
        double preTickCpuClocks = cpuClocks;
        delayTicks--;
        tick(step);
        double neededCpuClocks = preTickCpuClocks + ClocksPerTick;
        if (cpuClocks < neededCpuClocks) {
            cpuClocks = neededCpuClocks;
        }
    }
    if (remainder >= 0) {
        cpuClocks += remainder;
        audio_step(remainder);
    }
}
size_t ZsmBackend::render(void *buf, size_t maxlen) {
    size_t sample_type_len = 2;
    maxlen /= sample_type_len;
    while (audio_buf.size() <= maxlen) {
        tick(true);
    }
    size_t copied = copy_out(buf, maxlen) * sample_type_len;
    maxlen *= sample_type_len;
    return copied;
}
uint64_t ZsmBackend::get_min_samples() {
    return spec.size;
}
std::optional<uint64_t> ZsmBackend::get_max_samples() {
    return get_min_samples();
}
ZsmCommand ZsmBackend::get_command() {
    ZsmCommandId cmdid;
    uint8_t cmd_byte;
    file->read(&cmd_byte, 1, 1);
    if (cmd_byte == 0x80) {
        cmdid = ZsmEOF;
    } else {
        if ((cmd_byte >> 6) == 0) {
            cmdid = PsgWrite;
        } else if ((cmd_byte >> 6) == 0b01) {
            if (cmd_byte == 0b01000000) {
                cmdid = ExtCmd;
            } else {
                cmdid = FmWrite;
            }
        } else {
            cmdid = Delay;
        }
    }
    ZsmCommand output;
    output.id = cmdid;
    if (cmdid == ZsmEOF) {
        return output;
    } else if (cmdid == PsgWrite) {
        uint8_t value;
        file->read(&value, 1, 1);
        output.psg_write.reg = cmd_byte & 0x3F;
        output.psg_write.val = value;
    } else if (cmdid == FmWrite) {
        uint16_t _value;
        uint8_t *value = (uint8_t*)(void*)(&_value);
        uint8_t pairs = cmd_byte & 0b111111;
        output.fm_write.len = pairs;
        output.fm_write.regs = (reg_pair*)malloc((sizeof(reg_pair))*pairs);
        for (uint8_t i = 0; i < pairs; i++) {
        	file->read(value, 2, 1);
            output.fm_write.regs[i].reg = value[0];
            output.fm_write.regs[i].val = value[1];
        }
    } else if (cmdid == ExtCmd) {
        uint8_t ext_cmd_byte;
        file->read(&ext_cmd_byte, 1, 1);
        uint8_t bytes = ext_cmd_byte & 0x3F;
        uint8_t ch = ext_cmd_byte >> 6;
        output.extcmd.channel = ch;
        output.extcmd.bytes = bytes;
        if (ch == 1) {
        	output.extcmd.expansion.write_bytes = NULL;
        } else {
            output.extcmd.pcm = (uint8_t*)malloc(bytes); // Handles all other cases due to them being in a union, and each having the same type.
        }
        for (size_t i = 0; i < bytes; i++) {
            uint8_t byte;
            file->read(&byte, 1, 1);
            switch (ch) {
                case 0: {
                    output.extcmd.pcm[i] = byte;
                } break;
                case 1: {
                    if (i == 0) {
                        output.extcmd.expansion.chip_id = byte;
                    } else if (i == 1) {
                        output.extcmd.expansion.writes = byte;
                        output.extcmd.expansion.write_bytes = (uint8_t*)malloc(byte);
                    } else {
                        output.extcmd.expansion.write_bytes[i - 2] = byte;
                    }
                } break;
                case 2: {
                    output.extcmd.sync[i] = byte;
                } break;
                case 3: {
                    output.extcmd.custom[i] = byte;
                } break;
            }
        }
    } else if (cmdid == Delay) {
        output.delay = cmd_byte & 0x7F;
    }
    return output;
}
ZsmCommand::~ZsmCommand() {
    switch (id) {
        case ExtCmd: {
            if (extcmd.channel == 1) {
            	if (extcmd.expansion.write_bytes != NULL) {
             		free(extcmd.expansion.write_bytes);
	            }
            } else {
                free(extcmd.pcm);
            }
        } break;
        case FmWrite: {
            free(fm_write.regs);
        }
    }
}
void ZsmBackend::seek_internal(double position, bool loop) {
    switch_stream(0);
    file->seek(music_data_start, SeekType::SET);
    this->cpuClocks = 0.0;
    this->delayTicks = 0;
    this->ticks = 0.0;
    this->position = 0.0;
    while (this->position < position) {
        audio_buf.clear();
        try {
            tick(false);
        } catch (std::exception) {
            switch_stream(0);
            file->seek(music_data_start, SeekType::SET);
            this->cpuClocks = 0.0;
            this->delayTicks = 0;
            this->ticks = 0.0;
            this->position = 0.0;
            return;
        }
    }
    size_t samples = std::min((size_t)((this->position - position) * PSG_FREQ), audio_buf.size());
    while (samples--) {
        audio_buf.pop();
    }
    this->position = std::floor(position * PSG_FREQ) / PSG_FREQ;
}
void ZsmBackend::seek(double position) {
    seek_internal(position, false);
}
double ZsmBackend::get_position() {
    return position;
}
int ZsmBackend::get_stream_idx() {
    return 0;
}