#include <cctype>

/* S3M handling interface
 * Copyright (C) 1992,2003 Bisqwit (http://iki.fi/bisqwit/)
 */

#include "s3m.hh"

using std::fopen;
using std::fclose;
using std::fread;
using std::fgetc;
using std::fwrite;
using std::fputc;
using std::printf;
using std::memset;
using std::isprint;

static unsigned readword(FILE* fp)
{
    int c = fgetc(fp);
    return (fgetc(fp)<<8) | c;
}

static void writeword(FILE* fp, unsigned w)
{
    fputc(w&255, fp);
    fputc(w>>8, fp);
}

static void newpara(FILE* fp)
{
    long pos = ftell(fp);
    unsigned liika = pos & 15;
    if(!liika)return;
    static const char tmp[16] = {0};
    fwrite(tmp, 1, 16-liika, fp);
}


S3M::S3M(FILE* fp) :
    name("?"),
    flags(0), version(0x1320), ffi(2),
    globalvolume(64), cmdA(6), cmdT(125),
    mastervolume(48), stereo(false),
    ultraclick(10), panflags(0xFC),
    ok(true)
{
    memset(pansets, 0, sizeof pansets);
    memset(chansets, 255, sizeof chansets);
    if(fp) { ok = Load(fp); }
}

void S3M::instrument::Clear()
{
    type=0;
    filename = "";
    memset(data, 0, sizeof data);
    name = "";
    oldparaptr=0;
    audio.clear();
}

void S3M::instrument::MakeSMP()
{
    // data bytes format:
    //     0..3: Length 
    //     4..7: Loop begin
    //    8..11: Loop end
    //       12: Volume
    //       14: 0 (unpacked)
    //       15: 0=no loop, 1=loop
    //   16..19: C2Spd
    
    type = 1;
    
    data[0] = data[1] = data[2] = data[3] = 0;
    data[4] = data[5] = data[6] = data[7] = 0;
    data[8] = data[9] = data[10] = data[11] = 0;
    data[12] = 64;
    data[14] = 0;
    data[15] = 1;
    data[16] = 8363 & 255;
    data[17] = 8363 / 256;
    data[18] = data[19] = 0;
}

void S3M::instrument::MakeAME()
{
    type = 2;
    data[12] = 64;
    data[14] = 0;
    data[15] = 1;
    data[16] = 8363 & 255;
    data[17] = 8363 / 256;
}

void S3M::instrument::SetLoop(unsigned begin, unsigned end)
{
    data[4] = begin & 255;
    data[5] = begin / 256;
    data[8] = end & 255;
    data[9] = end / 256;
    data[15] = begin != end;
}
void S3M::instrument::SetC4SPD(unsigned c4spd)
{
    data[16] = c4spd & 255;
    data[17] = (c4spd >> 8) & 255;
    data[18] = (c4spd >> 16) & 255;
    data[19] = (c4spd >> 24) & 255;
}
void S3M::instrument::SetVolume(unsigned char vol)
{
    data[12] = vol;
}

void S3M::event::Clear()
{
    note=vol=255; ins=cmd=info=0;
}

bool S3M::Load(FILE* fp)
{
    ok = false;
    char Buf[32];
    fread(Buf, 1, 32, fp);
    if(Buf[0x1D] != 16) { /* invalid format */ return false; }
    Buf[0x1C] = 0;
    name = Buf;
    patterns.clear();
    unsigned ordnum = readword(fp);
    unsigned insnum = readword(fp);
    unsigned patnum = readword(fp);
    flags = readword(fp);
    version = readword(fp);
    ffi = readword(fp);
    if(fgetc(fp)!='S'
    || fgetc(fp)!='C'
    || fgetc(fp)!='R'
    || fgetc(fp)!='M') { /* invalid format */ return false; }
    
    instrus.resize(insnum);
    patterns.resize(patnum);
    
    globalvolume = fgetc(fp);
    cmdA = fgetc(fp);
    cmdT = fgetc(fp);
    mastervolume = fgetc(fp);
    stereo = mastervolume&128;
    mastervolume &= 127;
    ultraclick = fgetc(fp);
    panflags = fgetc(fp);
    fread(Buf, 1, 10, fp);
    fread(chansets, 1, 32, fp);
    orders.resize(ordnum);
    fread(&orders[0], 1, ordnum, fp);
    vector<unsigned> insptr(insnum);
    vector<unsigned> patptr(patnum);
    for(unsigned a=0; a<insnum; ++a) insptr[a] = readword(fp);
    for(unsigned a=0; a<patnum; ++a) patptr[a] = readword(fp);
    if(panflags == 0xFC)
        fread(pansets, 1, 32, fp);
    
    for(unsigned a=0; a<insnum; ++a)
    {
        fseek(fp, insptr[a]*16, SEEK_SET);
        instrument& tmp = instrus[a];
        tmp.oldparaptr = insptr[a];
        tmp.type = fgetc(fp);
        fread(Buf, 1, 12, fp);
        Buf[12] = 0;
        tmp.filename = Buf;
        unsigned b = fgetc(fp);
        unsigned memseg = readword(fp) + (b<<16);
        fread(tmp.data, 1, 32, fp);
        fread(Buf, 1, 28, fp);
        Buf[28] = 0;
        tmp.name = Buf;
        fread(Buf, 1, 4, fp); /* SCRS */
        tmp.audio.clear();
        if(memseg)
        {
            unsigned length = tmp.data[0] | (tmp.data[1]<<8);
            fseek(fp, memseg*16, SEEK_SET);
            tmp.audio.resize(length);
            fread(&tmp.audio[0], 1, length, fp);
        }
    }
    for(unsigned a=0; a<patnum; ++a)
    {
        if(!patptr[a])
        {
            patterns[a] = pattern(0);
            continue;
        }
        fseek(fp, patptr[a]*16, SEEK_SET);
        unsigned length = readword(fp);
        
        pattern tmp(length);
        fread(&tmp[0], 1, length, fp);
        tmp.oldparaptr = patptr[a];
        patterns[a] = tmp;
    }
    ok = true;
    return true;
}

bool S3M::Load(const string& fn)
{
    bool valid = false;
    FILE* fp = fopen(fn.c_str(), "rb");
    if(fp) { valid = Load(fp); fclose(fp); }
    ok = valid;
    return valid;
}

void S3M::Save(const string& fn)
{
    FILE* fp = fopen(fn.c_str(), "wb");
    if(fp) { Save(fp); fclose(fp); }
}

void S3M::Save(FILE* fp)
{
    char Buf[256]; // 32 bytes used, but allocate 256 just in case
    
    strncpy(Buf, name.c_str(), 28);
    Buf[0x1B] = 0;
    Buf[0x1C] = 0x1A;
    Buf[0x1D] = 16;
    fwrite(Buf, 1, 0x20, fp);
    writeword(fp, orders.size());
    writeword(fp, instrus.size());
    writeword(fp, patterns.size());
    writeword(fp, flags);
    writeword(fp, version);
    writeword(fp, ffi);
    fputc('S', fp);
    fputc('C', fp);
    fputc('R', fp);
    fputc('M', fp);
    fputc(globalvolume, fp);
    fputc(cmdA, fp);
    fputc(cmdT, fp);
    fputc(mastervolume + (stereo?128:0), fp);
    fputc(ultraclick, fp),
    fputc(panflags, fp);
    memset(Buf, 0, 10);
    fwrite(Buf, 1, 10, fp);
    fwrite(chansets, 1, 32, fp);
    fwrite(&orders[0], 1, orders.size(), fp);
    
    unsigned insnum = instrus.size();
    unsigned patnum = patterns.size();
    
    vector<unsigned> insptr(insnum); long instabptr = ftell(fp);
    for(unsigned a=0; a<insnum; ++a)writeword(fp, insptr[a]);
    
    vector<unsigned> patptr(patnum); long pattabptr = ftell(fp);
    for(unsigned a=0; a<patnum; ++a)writeword(fp, patptr[a]);
    if(panflags == 0xFC)
        fwrite(pansets, 1, 32, fp);

    for(unsigned a=0; a<insnum; ++a)
    {
        newpara(fp);
        insptr[a] = ftell(fp) >> 4;
        instrument& tmp = instrus[a];
        fputc(tmp.type, fp);
        strncpy(Buf, tmp.filename.c_str(), 12);
        fwrite(Buf, 1, 12, fp);
        
        Buf[0] = Buf[1] = Buf[2] = 0;
        fwrite(Buf, 1, 3, fp);  // memseg
        
        fwrite(tmp.data, 1, 32, fp);
        strncpy(Buf, tmp.name.c_str(), 28);
        fwrite(Buf, 1, 28, fp);
        fwrite("SCRS", 1, 4, fp);
    }
    for(unsigned a=0; a<patnum; ++a)
    {
        if(!patterns[a].size())
        {
            patptr[a] = 0;
            continue;
        }
        newpara(fp);
        patptr[a] = ftell(fp) >> 4;
        writeword(fp, patterns[a].size()+2);
        fwrite(&patterns[a][0], 1, patterns[a].size(), fp);
    }
    for(unsigned a=0; a<insnum; ++a)
    {
        unsigned memseg = 0;
        unsigned audiolen = instrus[a].audio.size();
        if(audiolen)
        {
            newpara(fp);
            memseg = ftell(fp) >> 4;
            fwrite(&instrus[a].audio[0], 1, audiolen, fp);
        }
        long p = ftell(fp);
        fseek(fp, insptr[a] * 16 + 13, SEEK_SET);
        Buf[0] = memseg >> 16;
        Buf[1] = (memseg     ) & 255;
        Buf[2] = (memseg >> 8) & 255;
        fwrite(Buf, 1, 3, fp);  // memseg
        if(audiolen)
        {
            Buf[0] = audiolen & 255;
            Buf[1] = (audiolen >> 8) & 255;
            fwrite(Buf, 1, 2, fp);
        }
        fseek(fp, p, SEEK_SET);
    }
    fseek(fp, instabptr, SEEK_SET);
    for(unsigned a=0; a<insnum; ++a)writeword(fp, insptr[a]);
    fseek(fp, pattabptr, SEEK_SET);
    for(unsigned a=0; a<patnum; ++a)writeword(fp, patptr[a]);
}

void S3M::Dump() const
{
    printf("\
Song name                    Flag Vers FFi  GVo Axx Txx MVo S UC PF \n");
    
    printf("%-28s %04X %04X %04X", name.c_str(), flags, version, ffi);
    printf(" %3d %3d %3d %3d", globalvolume, cmdA, cmdT, mastervolume);
    printf(" %c", stereo ? 'S' : 'M');
    printf(" %02X %02X\n", ultraclick, panflags);
    printf("Channels:");
    for(unsigned a=0; a<32; ++a)
    {
        putchar(' ');
        if(!(chansets[a] & 128))putchar('(');
        unsigned c = chansets[a] & 127;
        if(c < 8)printf("L%d", c+1);
        else if(c < 16)printf("R%d", c-8+1);
        else if(c < 25)printf("A%d", c-16+1);
        else if(c < 32)printf("A%c", "BSTCH"[c-25]);
        else if(c == 127)printf("--");
        else printf("?%02X", c);
        if(pansets[a] & 32)
            printf("@%u", pansets[a]);
        if(!(chansets[a] & 128))putchar(')');
    }
    printf("\nOrders:");
    for(unsigned a=0; a<orders.size(); ++a)printf(" %02X", orders[a]);
    printf("\nPattern Length At\n");
    for(unsigned a=0; a<patterns.size(); ++a)
        printf("%7d %-6u %X\n", a, patterns[a].size(), patterns[a].oldparaptr);
    printf("\
Instrument name             Filename.ext Databytes                        At   Length\n");
    for(unsigned a=0; a<instrus.size(); ++a)
    {
        printf("%-27s %-12s ", instrus[a].name.c_str(), instrus[a].filename.c_str());
        for(unsigned b=0; b<32; ++b)
        {
            char c = instrus[a].data[b];
            putchar(isprint(c) ? c : '.');
        }
        printf(" %-5X%u\n", instrus[a].oldparaptr, instrus[a].audio.size());
    }
}

void S3M::setname(const string& newname)
{
    name = newname.substr(0, 28);
}

void S3M::setsettings(unsigned char A, unsigned char T,
                      unsigned char globalvol, unsigned char mastervol,
                      bool stereoflag)
{
    cmdA = A;
    cmdT = T;
    globalvolume = globalvol;
    mastervolume = mastervol;
    stereo = stereoflag;
}

void S3M::setupchannel(unsigned chan, unsigned char type, unsigned char pan)
{
    if(chan >= 32)return;
    chansets[chan] = type;
    pansets[chan] = pan;
}

void S3M::setorder(unsigned ordernum, unsigned char value)
{
    if(ordernum > 255)ordernum = 255;
    if(orders.size() <= ordernum)
        orders.resize(ordernum+1);
    orders[ordernum] = value;
}

S3M::instrument& S3M::getinstrument(unsigned instrunum)
{
    if(instrunum >= 70)instrunum = 70;
    if(instrus.size() <= instrunum)
        instrus.resize(instrunum+1);
    return instrus[instrunum];
}

S3M::pattern& S3M::getpattern(unsigned patnum)
{
    if(patnum >= 99)patnum = 99;
    if(patterns.size() <= patnum)
        patterns.resize(patnum+1);
    return patterns[patnum];
}

void S3M::eventtable::setgeometry(unsigned rows, unsigned chans)
{
    rowcount = rows;
    channelcount = chans;
    events.resize(rows*chans);
}

void S3M::eventtable::loadchannel(unsigned chan, const vector<event>& channel)
{
    if(rowcount < channel.size())
    {
        rowcount = channel.size();
        events.resize(rowcount * channelcount);
    }
    for(unsigned a=0; a<channel.size(); ++a)
        events[a*channelcount + chan] = channel[a];
}

S3M::eventtable::eventtable()
{
}

S3M::eventtable::eventtable(const eventtable& src, unsigned row1, unsigned numrows)
    : channelcount(src.channelcount),
      rowcount(numrows),
      events(src.events.begin() + row1 * src.channelcount,
             src.events.begin() + (row1 + numrows) * src.channelcount)
{
}

S3M::eventtable S3M::eventtable::slice(unsigned row1, unsigned numrows) const
{
    S3M::eventtable res;
    res.setgeometry(numrows, channelcount);
    for(unsigned a=0; a<numrows; ++a)
    {
        unsigned r = row1 + a;
        if(r < rowcount)
        {
            for(unsigned c=0; c<channelcount; ++c)
                res.events[a * res.channelcount + c] = events[r * channelcount + c];
        }
    }
    return res;
}

S3M::pattern S3M::compresspattern(const eventtable& events, unsigned padto)
{
    pattern result;
    
    unsigned chancount = events.channelcount;
    unsigned rowcount  = events.rowcount;
    
    for(unsigned r=0; r<rowcount; ++r)
    {
        for(unsigned c=0; c<chancount; ++c)
        {
            const event &ev = events.events[c + r*chancount];
            unsigned char b = c;
            if(ev.note != 255 || ev.ins != 0)b |= 32;
            if(ev.vol  != 255)               b |= 64;
            if(ev.cmd  != 0)                 b |= 128;
            
            if(b != c)
            {
                result.push_back(b);
                
                if(b & 32) { result.push_back(ev.note); 
                             result.push_back(ev.ins); }
                if(b & 64) { result.push_back(ev.vol); }
                if(b & 128) { result.push_back(ev.cmd);
                              result.push_back(ev.info); }
            }
        }
        result.push_back(0);
    }
    while(rowcount < padto)
    {
        ++rowcount;
        result.push_back(0);
    }
    return result;
}