/* Copyright (C) 2016 Joel Yliluoma - http://iki.fi/bisqwit/
 * Redistribution and modifications are permitted under the rules
 * of Creative Commons Attribution-ShareAlike 3.0 license
 * https://creativecommons.org/licenses/by-sa/3.0/
 */
#include <vector>
#include <fstream>
#include <utility>
#include <cstdio>

static std::vector<unsigned char> rom;
static std::vector<bool>          space;

static char TranslateChar(unsigned char c)
{
    switch(c)
    {
        case 0xA1: return '1';
        case 0xA2: return '2';
        case 0xA3: return '3';
        case 0x40: return ' ';
        case 0x94: return '-';
        case 0x5F: return '!';
        case 0x5C: return '.';
        default: return c;
    }
}
static char TranslateEndingChar(unsigned char c)
{
    switch(c)
    {
        case 0x1C: return '.';
        case 0x1E: return '\'';
        case 0x20: return ' ';
        case 0x30 ... 0x39: return c;
        default: return c + 0x40;
    }
}



static unsigned ReadLEword(unsigned address)
{
    return rom[address] + rom[address+1]*256;
}
static unsigned ReadBEword(unsigned address)
{
    return rom[address]*256 + rom[address+1];
}

static void MarkFree(unsigned fromaddress, unsigned length)
{
    while(length--) space[fromaddress++] = true;
}

template<typename Translator>
void DumpText(unsigned fromaddress, unsigned length, Translator Translate)
{
   std::printf("\"");
   for(unsigned p=0; p<length; ++p)
   {
       char c = rom[fromaddress+p];
       std::printf("%c", Translate(c));
   }
   std::printf("\"\n");
}

void DumpScreen(unsigned tableaddress,
                unsigned baseaddress,
                unsigned tablelength,
                std::initializer_list<std::pair<unsigned/*where*/,unsigned/*plus*/>>
                    references)
{
    std::printf("SCREENTABLE\n");
    MarkFree(tableaddress, tablelength);
    for(const auto p: references)
        std::printf("\tREFER %04X %u\n", p.first, p.second);
    for(unsigned t=0; t<tablelength; ++t)
    {
        unsigned pos = rom[tableaddress+t];
        std::printf("\tPPU %04X ",  ReadBEword(baseaddress+pos));
        unsigned textlength = rom[baseaddress+ pos+2];
        DumpText(baseaddress+pos+3, textlength, TranslateChar);
        MarkFree(baseaddress, pos+3+textlength);
    }
}

void DumpFree()
{
    for(unsigned pos=0; pos<space.size(); ++pos)
        if(space[pos])
        {
            unsigned end = pos+1;
            while(end < space.size() && space[end]) ++end;
            std::printf("FREE %04X %u\n", pos, end-pos);
            pos = end-1;
        }
}

void Dump16StringTable(unsigned address, unsigned count)
{
    for(unsigned a=0; a<count; ++a)
    {
        std::printf("FSTRING 16 %X ", address);
        std::printf(" PPU %04X ", ReadBEword(address));
        DumpText(address+2, 14, TranslateChar);
        address += 16;
    }
}

static void Dump9String(unsigned straddress, unsigned referred)
{
    //std::printf("FSTRING 9 %X REFER %X %u ", straddress, referred, 0);
    std::printf("FSTRING 9 %X ", straddress);
    DumpText(straddress, 9, TranslateChar);
}

void DumpEndingStringTable(unsigned baseaddress, unsigned tableaddress,
                           unsigned count,
                           std::initializer_list<std::pair<unsigned/*where*/,unsigned/*plus*/>>
                               references)
{
    std::printf("ENDINGTABLE\n");
    for(auto r: references)
    {
        std::printf("REFER %X %u\n", r.first, r.second);
    }
    for(unsigned a=0; a<count; ++a)
    {
        unsigned length = rom[tableaddress+a];
        std::printf("\t");
        DumpText(baseaddress, length, TranslateEndingChar);
        MarkFree(baseaddress, length);
        baseaddress += length;
    }
    MarkFree(tableaddress, count);
}

int main()
{
    rom.resize(0x40000);
    space.resize(0x40000);
    std::ifstream f("megaman2.nes");
    f.seekg(0x10);
    f.read( (char*) &rom[0], rom.size());

    DumpScreen(0x36FBD, // Table of starting offsets
               0x36F39, // Into this data
               10,      // Table length is this much
               {{0x362E7+1,0}, // word to address+0
                {0x362F5+1,0}, // word to address+0
                {0x362F9+1,0}, // word to address+0
                {0x362ED+1,1}, // word to address+1
                {0x3698F+1,0}, // word to address+0
                {0x36996+1,0}, // word to address+0
                {0x3699D+1,0}, // word to address+0
                {0x369A5+1,0}, // word to address+0
                {0x3698B+1,2}, // word to starting offset table
               });

    Dump9String(0x371E0, 0x3712D);
    Dump16StringTable(0x37E1A, 20);
    DumpEndingStringTable(0x24C95, 0x24C59, 60,
                          {{0x24678+1,0}, // table reference high
                           {0x2467C+1,1}, // table reference low
                           {0x246C7+1,2}  // lengths reference word
                          });
/*
    Ending text begins at     0x24C95
    Lengths of strings are at 0x24C59
*/

    MarkFree(0x3FF87, 89);
    DumpFree();
}