// Copyright 2022 Charles Lohr, you may use this file or any portions herein under any of the BSD, MIT, or CC0 licenses.

#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>

#include <SPI.h>
#include <SD.h>

#include "default64mbdtc.h"

// SD card
#define SD_CS_PIN 10

// Just default RAM amount is 64MB.
uint32_t ram_amt = 64*1024*1024;
int fail_on_all_faults = 0;

static int64_t SimpleReadNumberInt( const char * number, int64_t defaultNumber );
static uint64_t GetTimeMicroseconds();
static void ResetKeyboardInput();
static void CaptureKeyboardInput();
static uint32_t HandleException( uint32_t ir, uint32_t retval );
static uint32_t HandleControlStore( uint32_t addy, uint32_t val );
static uint32_t HandleControlLoad( uint32_t addy );
static void HandleOtherCSRWrite( uint8_t * image, uint16_t csrno, uint32_t value );
static int32_t HandleOtherCSRRead( uint8_t * image, uint16_t csrno );
static void MiniSleep();
static int IsKBHit();
static int ReadKBByte();

// This is the functionality we want to override in the emulator.
//  think of this as the way the emulator's processor is connected to the outside world.
#define MINIRV32WARN( x... ) printf( x );
#define MINIRV32_DECORATE  static
#define MINI_RV32_RAM_SIZE ram_amt
#define MINIRV32_IMPLEMENTATION
#define MINIRV32_POSTEXEC( pc, ir, retval ) { if( retval > 0 ) { if( fail_on_all_faults ) { printf( "FAULT\n" ); return 3; } else retval = HandleException( ir, retval ); } }
#define MINIRV32_HANDLE_MEM_STORE_CONTROL( addy, val ) if( HandleControlStore( addy, val ) ) return val;
#define MINIRV32_HANDLE_MEM_LOAD_CONTROL( addy, rval ) rval = HandleControlLoad( addy );
#define MINIRV32_OTHERCSR_WRITE( csrno, value ) HandleOtherCSRWrite( image, csrno, value );
#define MINIRV32_OTHERCSR_READ( csrno, value ) value = HandleOtherCSRRead( image, csrno );

#include "mini-rv32ima.h"

uint8_t * ram_image = 0;
struct MiniRV32IMAState * core;
const char * kernel_command_line = 0;

static void DumpState( struct MiniRV32IMAState * core, uint8_t * ram_image );

int main(int argc, char** argv) {
    int i;
    long long instct = -1;
    int show_help = 0;
    int time_divisor = 1;
    int fixed_update = 0;
    int do_sleep = 1;
    int single_step = 0;
    int dtb_ptr = 0;
    const char* image_file_name = 0;
    const char* dtb_file_name = 0;

    for (i = 1; i < argc; i++) {
        const char* param = argv[i];
        int param_continue = 0;  // Can combine parameters, like -lpt x
        do {
            if (param[0] == '-' || param_continue) {
                switch (param[1]) {
                    case 'm': if (++i < argc) ram_amt = SimpleReadNumberInt(argv[i], ram_amt); break;
                    case 'c': if (++i < argc) instct = SimpleReadNumberInt(argv[i], -1); break;
                    case 'k': if (++i < argc) kernel_command_line = argv[i]; break;
                    case 'f': image_file_name = (++i < argc) ? argv[i] : 0; break;
                    case 'b': dtb_file_name = (++i < argc) ? argv[i] : 0; break;
                    case 'l': param_continue = 1; fixed_update = 1; break;
                    case 'p': param_continue = 1; do_sleep = 0; break;
                    case 's': param_continue = 1; single_step = 1; break;
                    case 'd': param_continue = 1; fail_on_all_faults = 1; break;
                    case 't': if (++i < argc) time_divisor = SimpleReadNumberInt(argv[i], 1); break;
                    default:
                        if (param_continue)
                            param_continue = 0;
                        else
                            show_help = 1;
                        break;
                }
            }
            else {
                show_help = 1;
                break;
            }
            param++;
        } while (param_continue);
    }

    if (show_help || image_file_name == 0 || time_divisor <= 0) {
        Serial.println("./mini-rv32imaf [parameters]");
        Serial.println("\t-m [ram amount]");
        Serial.println("\t-f [running image]");
        Serial.println("\t-k [kernel command line]");
        Serial.println("\t-b [dtb file, or 'disable']");
        Serial.println("\t-c instruction count");
        Serial.println("\t-s single step with full processor state");
        Serial.println("\t-t time divion base");
        Serial.println("\t-l lock time base to instruction count");
        Serial.println("\t-p disable sleep when wfi");
        Serial.println("\t-d fail out immediately on all faults");
        return 1;
    }

    ram_image = (uint8_t*)malloc(ram_amt);
    if (!ram_image) {
        Serial.println("Error: could not allocate system image.");
        return -4;
    }

restart:
{
    File f = SD.open(image_file_name, FILE_READ);
    if (!f) {
        char buffer[256];
        sprintf(buffer, "Error: \"%s\" not found", image_file_name);
        Serial.println(buffer);
        return -5;
    }

    // Seek to the end of the file to get the file size
    f.seek(f.size());
    long flen = f.position();
    f.seek(0);  // Seek back to the beginning of the file

    if (flen > ram_amt) {
        char buffer[256];
        sprintf(buffer, "Error: Could not fit RAM image (%ld bytes) into %d", flen, ram_amt);
        Serial.println(buffer);
        return -6;
    }

    memset(ram_image, 0, ram_amt);
    size_t bytesRead = 0;
    while (f.available()) {
        ram_image[bytesRead++] = f.read();
    }

    f.close();

    // Handle DTB file (if provided)
    if (dtb_file_name) {
        if (strcmp(dtb_file_name, "disable") == 0) {
            // No DTB reading
        } else {
            f = SD.open(dtb_file_name, FILE_READ);
            if (!f) {
                char buffer[256];
                sprintf(buffer, "Error: \"%s\" not found", dtb_file_name);
                Serial.println(buffer);
                return -5;
            }

            f.seek(f.size());
            long dtblen = f.position();
            f.seek(0);

            dtb_ptr = ram_amt - dtblen - sizeof(struct MiniRV32IMAState);
            bytesRead = 0;
            while (f.available()) {
                ram_image[dtb_ptr + bytesRead++] = f.read();
            }
            f.close();
        }
    } else {
        // Load a default DTB
        dtb_ptr = ram_amt - sizeof(default64mbdtb) - sizeof(struct MiniRV32IMAState);
        memcpy(ram_image + dtb_ptr, default64mbdtb, sizeof(default64mbdtb));
        if (kernel_command_line) {
            strncpy((char*)(ram_image + dtb_ptr + 0xc0), kernel_command_line, 54);
        }
    }
}

CaptureKeyboardInput();

core = (struct MiniRV32IMAState*)(ram_image + ram_amt - sizeof(struct MiniRV32IMAState));
core->pc = MINIRV32_RAM_IMAGE_OFFSET;
core->regs[10] = 0x00; // hart ID
core->regs[11] = dtb_ptr ? (dtb_ptr + MINIRV32_RAM_IMAGE_OFFSET) : 0; // dtb_pa (Must be valid pointer)
core->extraflags |= 3; // Machine-mode.

// Update system ram size in DTB if needed
if (dtb_file_name == 0) {
    uint32_t* dtb = (uint32_t*)(ram_image + dtb_ptr);
    if (dtb[0x13c / 4] == 0x00c0ff03) {
        uint32_t validram = dtb_ptr;
        dtb[0x13c / 4] = (validram >> 24) | (((validram >> 16) & 0xff) << 8) | (((validram >> 8) & 0xff) << 16) | (validram & 0xff);
    }
}

uint64_t rt;
uint64_t lastTime = (fixed_update) ? 0 : (GetTimeMicroseconds() / time_divisor);
int instrs_per_flip = single_step ? 1 : 1024;

for (rt = 0; rt < instct + 1 || instct < 0; rt += instrs_per_flip) {
    uint64_t* this_ccount = ((uint64_t*)&core->cyclel);
    uint32_t elapsedUs = 0;
    if (fixed_update) {
        elapsedUs = *this_ccount / time_divisor - lastTime;
    } else {
        elapsedUs = GetTimeMicroseconds() / time_divisor - lastTime;
    }
    lastTime += elapsedUs;

    if (single_step) {
        DumpState(core, ram_image);
    }

    int ret = MiniRV32IMAStep(core, ram_image, 0, elapsedUs, instrs_per_flip);
    switch (ret) {
        case 0:
            break;
        case 1:
            if (do_sleep) MiniSleep();
            *this_ccount += instrs_per_flip;
            break;
        case 3:
            instct = 0;
            break;
        case 0x7777:
            goto restart;  // syscon code for restart
        case 0x5555:
            printf("POWEROFF@0x%08x%08x\n", core->cycleh, core->cyclel);
            return 0; // syscon code for power-off
        default:
            printf("Unknown failure\n");
            break;
    }
}

DumpState(core, ram_image);
}



//////////////////////////////////////////////////////////////////////////
// Platform-specific functionality
//////////////////////////////////////////////////////////////////////////


#if defined(WINDOWS) || defined(WIN32) || defined(_WIN32)

#include <windows.h>
#include <conio.h>

#define strtoll _strtoi64

static void CaptureKeyboardInput()
{
	system(""); // Poorly documented tick: Enable VT100 Windows mode.
}

static void ResetKeyboardInput()
{
}

static void MiniSleep()
{
	Sleep(1);
}

static uint64_t GetTimeMicroseconds()
{
	static LARGE_INTEGER lpf;
	LARGE_INTEGER li;

	if( !lpf.QuadPart )
		QueryPerformanceFrequency( &lpf );

	QueryPerformanceCounter( &li );
	return ((uint64_t)li.QuadPart * 1000000LL) / (uint64_t)lpf.QuadPart;
}


static int IsKBHit()
{
	return _kbhit();
}

static int ReadKBByte()
{
	// This code is kind of tricky, but used to convert windows arrow keys
	// to VT100 arrow keys.
	static int is_escape_sequence = 0;
	int r;
	if( is_escape_sequence == 1 )
	{
		is_escape_sequence++;
		return '[';
	}

	r = _getch();

	if( is_escape_sequence )
	{
		is_escape_sequence = 0;
		switch( r )
		{
			case 'H': return 'A'; // Up
			case 'P': return 'B'; // Down
			case 'K': return 'D'; // Left
			case 'M': return 'C'; // Right
			case 'G': return 'H'; // Home
			case 'O': return 'F'; // End
			default: return r; // Unknown code.
		}
	}
	else
	{
		switch( r )
		{
			case 13: return 10; //cr->lf
			case 224: is_escape_sequence = 1; return 27; // Escape arrow keys
			default: return r;
		}
	}
}

#else

//#include <sys/ioctl.h> -- NOT A THING ON ARDUINO MEGA
//#include <termios.h> -- NOT A THING ON ARDUINO MEGA
#include <unistd.h>
#include <signal.h>
//#include <sys/time.h> -- NOT A THING ON ARDUINO MEGA

// MEGA Fixes
#include <Wire.h>
#include <RTClib.h>

// Real Time Clock
RTC_DS1307 rtc;

// usleep
static void usleep(long long time)
{
    delayMicroseconds(time);  // Arduino's function to sleep for microseconds
}

// TODO:
/*
Replace time with RTC
*/

static void CtrlC()
{
	DumpState( core, ram_image);
	exit( 0 );
}

// Override keyboard, so we can capture all keyboard input for the VM.
static void CaptureKeyboardInput()
{
	// Hook exit, because we want to re-enable keyboard.
	atexit(ResetKeyboardInput);
	//signal(SIGINT, CtrlC);

	//struct termios term;
	//tcgetattr(0, &term);
	//term.c_lflag &= ~(ICANON | ECHO); // Disable echo as well
	//tcsetattr(0, TCSANOW, &term);
}

static void ResetKeyboardInput()
{
	// Re-enable echo, etc. on keyboard.
	//struct termios term;
	//tcgetattr(0, &term);
	//term.c_lflag |= ICANON | ECHO;
	//tcsetattr(0, TCSANOW, &term);
}

static void MiniSleep()
{
	usleep(500);
}

static uint64_t GetTimeMicroseconds()
{
    DateTime now = rtc.now();  // Get the current time from the RTC
    
    // Get the number of seconds since epoch (1970-01-01 00:00:00 UTC)
    uint32_t seconds = now.unixtime();
    
    // Convert seconds to microseconds
    uint64_t microseconds = (uint64_t)seconds * 1000000LL;
    
    // Add the current microseconds (DS1307 is only accurate to seconds, no sub-second precision)
    microseconds += now.second() * 1000000LL;  // This is a rough approximation
    
    return microseconds;
}

static int is_eofd;

static int ReadKBByte()
{
	if( is_eofd ) return 0xffffffff;
	char rxchar = 0;
	//int rread = read(fileno(stdin), (char*)&rxchar, 1);

	//if( rread > 0 ) // Tricky: getchar can't be used with arrow keys.
	//	return rxchar;
	//else
		return -1;
}

static int IsKBHit()
{
	if( is_eofd ) return -1;
	int byteswaiting;
	//ioctl(0, FIONREAD, &byteswaiting);
	//if( !byteswaiting && write( fileno(stdin), 0, 0 ) != 0 ) { is_eofd = 1; return -1; } // Is end-of-file for 
	return !!byteswaiting;
}


#endif


//////////////////////////////////////////////////////////////////////////
// Rest of functions functionality
//////////////////////////////////////////////////////////////////////////

static uint32_t HandleException( uint32_t ir, uint32_t code )
{
	// Weird opcode emitted by duktape on exit.
	if( code == 3 )
	{
		// Could handle other opcodes here.
	}
	return code;
}

static uint32_t HandleControlStore( uint32_t addy, uint32_t val )
{
	if( addy == 0x10000000 ) //UART 8250 / 16550 Data Buffer
	{
		printf( "%c", val );
		fflush( stdout );
	}
	else if( addy == 0x11004004 ) //CLNT
		core->timermatchh = val;
	else if( addy == 0x11004000 ) //CLNT
		core->timermatchl = val;
	else if( addy == 0x11100000 ) //SYSCON (reboot, poweroff, etc.)
	{
		core->pc = core->pc + 4;
		return val; // NOTE: PC will be PC of Syscon.
	}
	return 0;
}


static uint32_t HandleControlLoad( uint32_t addy )
{
	// Emulating a 8250 / 16550 UART
	if( addy == 0x10000005 )
		return 0x60 | IsKBHit();
	else if( addy == 0x10000000 && IsKBHit() )
		return ReadKBByte();
	else if( addy == 0x1100bffc ) // https://chromitem-soc.readthedocs.io/en/latest/clint.html
		return core->timerh;
	else if( addy == 0x1100bff8 )
		return core->timerl;
	return 0;
}

static void HandleOtherCSRWrite( uint8_t * image, uint16_t csrno, uint32_t value )
{
	if( csrno == 0x136 )
	{
		printf( "%d", value ); fflush( stdout );
	}
	if( csrno == 0x137 )
	{
		printf( "%08x", value ); fflush( stdout );
	}
	else if( csrno == 0x138 )
	{
		//Print "string"
		uint32_t ptrstart = value - MINIRV32_RAM_IMAGE_OFFSET;
		uint32_t ptrend = ptrstart;
		if( ptrstart >= ram_amt )
			printf( "DEBUG PASSED INVALID PTR (%08x)\n", value );
		while( ptrend < ram_amt )
		{
			if( image[ptrend] == 0 ) break;
			ptrend++;
		}
		if( ptrend != ptrstart )
			fwrite( image + ptrstart, ptrend - ptrstart, 1, stdout );
	}
	else if( csrno == 0x139 )
	{
		putchar( value ); fflush( stdout );
	}
}

static int32_t HandleOtherCSRRead( uint8_t * image, uint16_t csrno )
{
	if( csrno == 0x140 )
	{
		if( !IsKBHit() ) return -1;
		return ReadKBByte();
	}
	return 0;
}

static int64_t SimpleReadNumberInt( const char * number, int64_t defaultNumber )
{
    if ( !number || !number[0] ) return defaultNumber;

    int radix = 10;
    if ( number[0] == '0' )
    {
        char nc = number[1];
        number += 2;
        if ( nc == 0 ) return 0;  // "0" is just 0
        else if ( nc == 'x' ) radix = 16;  // Hexadecimal
        else if ( nc == 'b' ) radix = 2;   // Binary
        else { number--; radix = 8; }      // Octal
    }

    int64_t ret = 0;
    bool negative = false;

    // Handle negative numbers
    if (number[0] == '-') {
        negative = true;
        number++;
    }

    // Loop through the string and convert to number
    while (*number)
    {
        char c = *number++;
        int digit;

        // Convert char to corresponding digit based on radix
        if (c >= '0' && c <= '9') {
            digit = c - '0';
        } 
        else if (c >= 'a' && c <= 'f' && radix == 16) {
            digit = c - 'a' + 10;
        }
        else if (c >= 'A' && c <= 'F' && radix == 16) {
            digit = c - 'A' + 10;
        } 
        else if (c == 'b' && radix == 2) {
            digit = 1;  // Binary handling
        }
        else if (c == '0' && radix == 8) {
            digit = 0;  // Octal handling
        } else {
            // If the character is not valid for the current radix, return default number
            return defaultNumber;
        }

        // Make sure the digit is within the correct range for the radix
        if (digit >= radix) {
            return defaultNumber;
        }

        ret = ret * radix + digit;
    }

    return negative ? -ret : ret; // Handle negative numbers
}


static void DumpState( struct MiniRV32IMAState * core, uint8_t * ram_image )
{
	uint32_t pc = core->pc;
	uint32_t pc_offset = pc - MINIRV32_RAM_IMAGE_OFFSET;
	uint32_t ir = 0;

	printf( "PC: %08x ", pc );
	if( pc_offset >= 0 && pc_offset < ram_amt - 3 )
	{
		ir = *((uint32_t*)(&((uint8_t*)ram_image)[pc_offset]));
		printf( "[0x%08x] ", ir ); 
	}
	else
		printf( "[xxxxxxxxxx] " ); 
	uint32_t * regs = core->regs;
	printf( "Z:%08x ra:%08x sp:%08x gp:%08x tp:%08x t0:%08x t1:%08x t2:%08x s0:%08x s1:%08x a0:%08x a1:%08x a2:%08x a3:%08x a4:%08x a5:%08x ",
		regs[0], regs[1], regs[2], regs[3], regs[4], regs[5], regs[6], regs[7],
		regs[8], regs[9], regs[10], regs[11], regs[12], regs[13], regs[14], regs[15] );
	printf( "a6:%08x a7:%08x s2:%08x s3:%08x s4:%08x s5:%08x s6:%08x s7:%08x s8:%08x s9:%08x s10:%08x s11:%08x t3:%08x t4:%08x t5:%08x t6:%08x\n",
		regs[16], regs[17], regs[18], regs[19], regs[20], regs[21], regs[22], regs[23],
		regs[24], regs[25], regs[26], regs[27], regs[28], regs[29], regs[30], regs[31] );
}

void setup() {
	// Setup External Devices
	Serial.begin(9600);
	Wire.begin();
	
	// Initialize the RTC
	if (!rtc.begin()) {
			Serial.println("Couldn't find RTC");
			while (1);
	}
	
	// Check if the RTC lost power and set the time if necessary
	if (!rtc.isrunning()) {
			Serial.println("RTC is NOT running, setting the time...");
			// Set the RTC to a known time (use your desired start time)
			rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
	}

  if (!SD.begin(SD_CS_PIN)) {
    Serial.println("SD card initialization failed!");
    return;
  }

  Serial.println("SD card initialized.");

	// Call main
	char* arg1 = "program";
	char* argv[] = {arg1};
	main(1, argv);
}


void loop() {

}