/*
 *  PSX-Tools Bundle Pack
 *  Copyright (C) 2002-2003 Nicolas "Pixel" Noble
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

/* $Id: luacd.cpp,v 1.2 2003-12-07 04:44:39 pixel Exp $ */

#include "luacd.h"


/****************************\
|**  class cdutils exports **|
\****************************/

Luacdutils::Luacdutils(cdutils * _cd) : cd(_cd) { }

enum cdutils_methods_t {
    CDUTILS_SETISOW = 0,
    CDUTILS_GUESSTYPE,
    CDUTILS_SECTORSEEK,
    CDUTILS_READSECTOR,
    CDUTILS_READDATAS,
    CDUTILS_READFILE,
    CDUTILS_WRITESECTOR,
    CDUTILS_WRITEDATAS,
    CDUTILS_WRITEFILE,
    CDUTILS_GETISOINFOS,
    CDUTILS_GETPTINFOS,
    CDUTILS_FINDPATH,
    CDUTILS_FINDPARENT,
    CDUTILS_FINDDIRENTRY,
};

enum cdutils_functions_t {
    CDUTILS_NEWCDUTILS = 0,
    CDUTILS_SWAPWORD,
    CDUTILS_SWAPDWORD,
    CDUTILS_FROM_BCD,
    CDUTILS_TO_BCD,
    CDUTILS_IS_VALID_BCD,
    CDUTILS_FROM_MSF,
};

struct lua_functypes_t cdutils_methods[] = {
    { CDUTILS_SETISOW,      "set_iso_w",    1, 1, {LUA_OBJECT} },
    { CDUTILS_GUESSTYPE,    "guesstype",    0, 1, {LUA_NUMBER} },
    { CDUTILS_SECTORSEEK,   "sectorseek",   1, 1, {LUA_NUMBER} },
    { CDUTILS_READSECTOR,   "readsector",   0, 2, {LUA_NUMBER, LUA_NUMBER} },
    { CDUTILS_READDATAS,    "readdatas",    3, 3, {LUA_NUMBER, LUA_NUMBER, LUA_NUMBER} },
    { CDUTILS_READFILE,     "readfile",     4, 4, {LUA_OBJECT, LUA_NUMBER, LUA_NUMBER, LUA_NUMBER} },
    { CDUTILS_WRITESECTOR,  "writesector",  1, 3, {LUA_TABLE, LUA_NUMBER, LUA_NUMBER} },
    { CDUTILS_WRITEDATAS,   "writedatas",   4, 4, {LUA_TABLE, LUA_NUMBER, LUA_NUMBER, LUA_NUMBER} },
    { CDUTILS_WRITEFILE,    "writefile",    1, 3, {LUA_OBJECT, LUA_NUMBER, LUA_NUMBER} },
    { CDUTILS_GETISOINFOS,  "getisoinfos",  0, 0, 0 },
    { CDUTILS_GETPTINFOS,   "getptinfos",   0, 0, 0 },
    { CDUTILS_FINDPATH,     "findpath",     1, 1, {LUA_STRING} },
    { CDUTILS_FINDPARENT,   "findparent",   1, 1, {LUA_STRING} },
    { CDUTILS_FINDDIRENTRY, "finddirentry", 2, 2, {LUA_OBJECT, LUA_STRING} },
    { -1, 0, 0, 0, 0 }
};

struct lua_functypes_t cdutils_functions[] = {
    { CDUTILS_NEWCDUTILS,   "cdutils" ,     1, 2, {LUA_OBJECT, LUA_OBJECT} },
    { CDUTILS_SWAPWORD,     "swapword",     1, 1, {LUA_NUMBER} },
    { CDUTILS_SWAPDWORD,    "swapdword",    1, 1, {LUA_NUMBER} },
    { CDUTILS_FROM_BCD,     "from_BCD",     1, 1, {LUA_NUMBER} },
    { CDUTILS_TO_BCD,       "to_BCD",       1, 1, {LUA_NUMBER} },
    { CDUTILS_IS_VALID_BCD, "is_valid_BCD", 1, 1, {LUA_NUMBER} },
    { CDUTILS_FROM_MSF,     "from_MSF",     1, 4, {LUA_NUMBER, LUA_NUMBER, LUA_NUMBER, LUA_NUMBER} },
    { -1, 0, 0, 0, 0 }
};

class sLua_cdutils : public Base {
  public:
    DECLARE_METHOD(cdutils, CDUTILS_SETISOW);
    DECLARE_METHOD(cdutils, CDUTILS_GUESSTYPE);
    DECLARE_METHOD(cdutils, CDUTILS_SECTORSEEK);
    DECLARE_METHOD(cdutils, CDUTILS_READSECTOR);
    DECLARE_METHOD(cdutils, CDUTILS_READDATAS);
    DECLARE_METHOD(cdutils, CDUTILS_READFILE);
    DECLARE_METHOD(cdutils, CDUTILS_WRITESECTOR);
    DECLARE_METHOD(cdutils, CDUTILS_WRITEDATAS);
    DECLARE_METHOD(cdutils, CDUTILS_WRITEFILE);
    DECLARE_METHOD(cdutils, CDUTILS_GETISOINFOS);
    DECLARE_METHOD(cdutils, CDUTILS_GETPTINFOS);
    DECLARE_METHOD(cdutils, CDUTILS_FINDPATH);
    DECLARE_METHOD(cdutils, CDUTILS_FINDPARENT);
    DECLARE_METHOD(cdutils, CDUTILS_FINDDIRENTRY);

    DECLARE_FUNCTION(cdutils, CDUTILS_NEWCDUTILS);
    DECLARE_FUNCTION(cdutils, CDUTILS_SWAPWORD);
    DECLARE_FUNCTION(cdutils, CDUTILS_SWAPDWORD);
    DECLARE_FUNCTION(cdutils, CDUTILS_FROM_BCD);
    DECLARE_FUNCTION(cdutils, CDUTILS_TO_BCD);
    DECLARE_FUNCTION(cdutils, CDUTILS_IS_VALID_BCD);
    DECLARE_FUNCTION(cdutils, CDUTILS_FROM_MSF);

  private:
    static int cdutils_proceed(Lua * L, int n, cdutils * obj, int caller);
    static int cdutils_proceed_statics(Lua * L, int n, int caller);
};

void Luacdutils::pushmembers(Lua * L) {
    pushme(L, cd);

    PUSH_METHOD(cdutils, CDUTILS_SETISOW);
    PUSH_METHOD(cdutils, CDUTILS_GUESSTYPE);
    PUSH_METHOD(cdutils, CDUTILS_SECTORSEEK);
    PUSH_METHOD(cdutils, CDUTILS_READSECTOR);
    PUSH_METHOD(cdutils, CDUTILS_READDATAS);
    PUSH_METHOD(cdutils, CDUTILS_READFILE);
    PUSH_METHOD(cdutils, CDUTILS_WRITESECTOR);
    PUSH_METHOD(cdutils, CDUTILS_WRITEDATAS);
    PUSH_METHOD(cdutils, CDUTILS_WRITEFILE);
    PUSH_METHOD(cdutils, CDUTILS_GETISOINFOS);
    PUSH_METHOD(cdutils, CDUTILS_GETPTINFOS);
    PUSH_METHOD(cdutils, CDUTILS_FINDPATH);
    PUSH_METHOD(cdutils, CDUTILS_FINDPARENT);
    PUSH_METHOD(cdutils, CDUTILS_FINDDIRENTRY);
}

void Luacdutils::pushstatics(Lua * L) throw (GeneralException) {
    CHECK_METHODS(cdutils);
    CHECK_FUNCTIONS(cdutils);

    PUSH_FUNCTION(cdutils, CDUTILS_NEWCDUTILS);
    PUSH_FUNCTION(cdutils, CDUTILS_SWAPWORD);
    PUSH_FUNCTION(cdutils, CDUTILS_SWAPDWORD);
    PUSH_FUNCTION(cdutils, CDUTILS_FROM_BCD);
    PUSH_FUNCTION(cdutils, CDUTILS_TO_BCD);
    PUSH_FUNCTION(cdutils, CDUTILS_IS_VALID_BCD);
    PUSH_FUNCTION(cdutils, CDUTILS_FROM_MSF);

    L->push("MODE0");
    L->push((lua_Number) MODE0);
    L->setvar();

    L->push("MODE1");
    L->push((lua_Number) MODE1);
    L->setvar();

    L->push("MODE2");
    L->push((lua_Number) MODE2);
    L->setvar();

    L->push("MODE2_FORM1");
    L->push((lua_Number) MODE2_FORM1);
    L->setvar();

    L->push("MODE2_FORM2");
    L->push((lua_Number) MODE2_FORM2);
    L->setvar();

    L->push("MORE_RAW");
    L->push((lua_Number) MODE_RAW);
    L->setvar();

    L->push("GUESS");
    L->push((lua_Number) GUESS);
    L->setvar();

    int i;

    L->push("sec_sizes");
    L->newtable();
    for (i = 0; i <= GUESS; i++) {
        L->push((lua_Number) i);
        L->push((lua_Number) sec_sizes[i]);
        L->settable();
    }
    L->setvar();

    L->push("sec_offsts");
    L->newtable();
    for (i = 0; i <= GUESS; i++) {
        L->push((lua_Number) i);
        L->push((lua_Number) sec_offsts[i]);
        L->settable();
    }
    L->setvar();

    L->push("sec_modes");
    L->newtable();
    for (i = 0; i <= GUESS; i++) {
        L->push((lua_Number) i);
        L->push(sec_modes[i]);
        L->settable();
    }
    L->setvar();
}

int sLua_cdutils::cdutils_proceed(Lua * L, int n, cdutils * cd, int caller) {
    int r = 0, sect = -1, mode = GUESS, size, i;
    Handle * h;
    Byte sdatas[2352], * datas;
    String path;
    cdutils::DirEntry * dir, * bdir, * adir;

    switch(caller) {
    case CDUTILS_SETISOW:
        h = (Handle *) LuaObject::getme(L, 2);
        cd->set_iso_w(h);
        break;
    case CDUTILS_GUESSTYPE:
        if (n == 1) {
            sect = L->tonumber();
        }
        L->push((lua_Number) cd->guess_type(sect));
        r = 1;
        break;
    case CDUTILS_SECTORSEEK:
        sect = L->tonumber();
        cd->sector_seek(sect);
        break;
    case CDUTILS_READSECTOR:
        if (n >= 1)
            mode = L->tonumber(2);
        if (n == 2)
            sect = L->tonumber(3);
        size = cd->read_sector(sdatas, mode, sect);
        L->newtable();
        for (i = 0; i < size; i++) {
            L->push((lua_Number) i);
            L->push((lua_Number) sdatas[i]);
            L->settable();
        }
        r = 1;
        break;
    case CDUTILS_READDATAS:
        mode = L->tonumber(2);
        sect = L->tonumber(3);
        size = L->tonumber(4);
        datas = (Byte *) malloc(size);
        cd->read_datas(datas, mode, sect, size);
        L->newtable();
        for (i = 0; i < size; i++) {
            L->push((lua_Number) i);
            L->push((lua_Number) datas[i]);
            L->settable();
        }
        r = 1;
        free(datas);
        break;
    case CDUTILS_READFILE:
        h = (Handle *) LuaObject::getme(L, 2);
        mode = L->tonumber(3);
        sect = L->tonumber(4);
        size = L->tonumber(5);
        cd->read_file(h, mode, sect, size);
        break;
    case CDUTILS_WRITESECTOR:
        if (n >= 2)
            mode = L->tonumber(3);
        if (n == 3)
            sect = L->tonumber(4);
        for (i = 0; i < 2352; i++) {
            L->push((lua_Number) i);
            L->gettable(2);
            sdatas[i] = L->tonumber();
            L->pop();
        }
        cd->write_sector(datas, mode, sect);
        break;
    case CDUTILS_WRITEDATAS:
        mode = L->tonumber(3);
        sect = L->tonumber(4);
        size = L->tonumber(5);
        datas = (Byte *) malloc(size);

        for (i = 0; i < size; i++) {
            L->push((lua_Number) i);
            L->gettable(2);
            sdatas[i] = L->tonumber();
            L->pop();
        }
        cd->write_datas(datas, mode, sect, size);
        free(datas);
        break;
    case CDUTILS_WRITEFILE:
        h = (Handle *) LuaObject::getme(L, 2);
        if (n >= 2)
            mode = L->tonumber(3);
        if (n == 3)
            sect = L->tonumber(4);
        cd->write_file(h, mode, sect);
        break;
    case CDUTILS_GETISOINFOS:
        L->push((lua_Number) cd->get_iso_infos());
        r = 1;
        break;
    case CDUTILS_GETPTINFOS:
        L->push((lua_Number) cd->get_pt_infos());
        r = 1;
        break;
    case CDUTILS_FINDPATH:
        path = L->tostring(2);
        bdir = cd->find_path(&datas, path);
        dir = (cdutils::DirEntry *) malloc(bdir->R);
        memcpy(dir, bdir, bdir->R);
        {
            Luadirentry ldir(dir);
            ldir.pushdestruct(L);
        }
        r = 1;
        free(datas);
        break;
    case CDUTILS_FINDPARENT:
        path = L->tostring(2);
        bdir = cd->find_parent(&datas, path);
        dir = (cdutils::DirEntry *) malloc(bdir->R);
        memcpy(dir, bdir, bdir->R);
        {
            Luadirentry ldir(dir);
            ldir.pushdestruct(L);
        }
        r = 1;
        free(datas);
        break;
    case CDUTILS_FINDDIRENTRY:
        adir = (cdutils::DirEntry *) LuaObject::getme(L, 2);
        path = L->tostring(3);
        bdir = cd->find_dir_entry(&datas, adir, path);
        dir = (cdutils::DirEntry *) malloc(bdir->R);
        memcpy(dir, bdir, bdir->R);
        {
            Luadirentry ldir(dir);
            ldir.pushdestruct(L);
        }
        r = 1;
        free(datas);
        break;
    }
    return r;
}

int sLua_cdutils::cdutils_proceed_statics(Lua * L, int n, int caller) {
    int r = 0;
    Uint32 x;

    switch(caller) {
    case CDUTILS_NEWCDUTILS:
        /***TODO***/
        break;
    case CDUTILS_SWAPWORD:
        x = L->tonumber();
        L->push((lua_Number) cdutils::swap_word(x));
        r = 1;
        break;
    case CDUTILS_SWAPDWORD:
        x = L->tonumber();
        L->push((lua_Number) cdutils::swap_dword(x));
        r = 1;
        break;
    case CDUTILS_FROM_BCD:
        x = L->tonumber();
        L->push((lua_Number) cdutils::from_BCD(x));
        r = 1;
        break;
    case CDUTILS_TO_BCD:
        x = L->tonumber();
        L->push((lua_Number) cdutils::to_BCD(x));
        r = 1;
        break;
    case CDUTILS_IS_VALID_BCD:
        x = L->tonumber();
        L->push(cdutils::is_valid_BCD(x));
        r = 1;
        break;
    case CDUTILS_FROM_MSF:
        /***TODO***/
        break;
    }

    return r;
}


/***************************\
|**  class cdfile exports **|
\***************************/

Luacdfile::Luacdfile(cdfile * h) : LuaHandle(h) { }

enum cdfile_functions_t {
    CDFILE_NEWCDFILE = 0,
};

struct lua_functypes_t cdfile_functions[] = {
    { CDFILE_NEWCDFILE, "cdfile", 1, 4, {LUA_OBJECT, LUA_ANY, LUA_NUMBER, LUA_NUMBER} },
    { -1, 0, 0, 0, 0 }
};

class sLua_cdfile : public Base {
  public:
    DECLARE_FUNCTION(cdfile, CDFILE_NEWCDFILE);
  private:
    static int cdfile_proceed_statics(Lua * L, int n, int caller);
};

void Luacdfile::pushmembers(Lua * L) {
    LuaHandle::pushmembers(L);
}

void Luacdfile::pushstatics(Lua * L) {
    CHECK_FUNCTIONS(cdfile);
    PUSH_FUNCTION(cdfile, CDFILE_NEWCDFILE);
}

int sLua_cdfile::cdfile_proceed_statics(Lua * L, int n, int caller) {
    int r = 0;

    switch(caller) {
    case CDFILE_NEWCDFILE:
        /****TODO****/
        break;
    }

    return r;
}



Luadirentry::Luadirentry(cdutils::DirEntry * _dir) : dir(_dir) { }

typedef cdutils::DirEntry direntry;

enum direntry_methods_t {
    DIRENTRY_INDEX = 0,
};

struct lua_functypes_t direntry_methods[] = {
    { DIRENTRY_INDEX, "index", 2, 2, {LUA_OBJECT, LUA_STRING} },
    { -1, 0, 0, 0, 0 }
};

class sLua_direntry : public Base {
  public:
      DECLARE_METHOD(direntry, DIRENTRY_INDEX);
  private:
    static int direntry_proceed(Lua * L, int n, direntry * obj, int caller);
};

void Luadirentry::pushmembers(Lua * L) {
    pushme(L, dir);

    PUSH_METAMETHOD(direntry, DIRENTRY_INDEX);
}

int sLua_direntry::direntry_proceed(Lua * L, int n, direntry * dir, int caller) {
    int r = 0;
    String index;

    switch (caller) {
    case DIRENTRY_INDEX:
        index = L->tostring();
        r = 1;
        if (index == "R") {
            L->push((lua_Number) dir->R);
        } else if (index == "NExt") {
            L->push((lua_Number) dir->NExt);
        } else if (index == "Sector") {
            L->push((lua_Number) dir->Sector);
        } else if (index == "Size") {
            L->push((lua_Number) dir->Size);
        } else if (index == "Year") {
            L->push((lua_Number) dir->Year);
        } else if (index == "Month") {
            L->push((lua_Number) dir->Month);
        } else if (index == "Day") {
            L->push((lua_Number) dir->Day);
        } else if (index == "Hour") {
            L->push((lua_Number) dir->Hour);
        } else if (index == "Minute") {
            L->push((lua_Number) dir->Minute);
        } else if (index == "Second") {
            L->push((lua_Number) dir->Second);
        } else if (index == "Offset") {
            L->push((lua_Number) dir->Offset);
        } else if (index == "Flags") {
            L->push((lua_Number) dir->Flags);
        } else if (index == "HandleUnit") {
            L->push((lua_Number) dir->HandleUnit);
        } else if (index == "HandleGap") {
            L->push((lua_Number) dir->HandleGap);
        } else if (index == "VolSeq") {
            L->push((lua_Number) dir->VolSeq);
        } else if (index == "N") {
            L->push((lua_Number) dir->N);
        } else if (index == "id") {
            char pbuf[256];
            memcpy(pbuf, dir->id, dir->N);
            pbuf[dir->N] = 0;
            L->push(pbuf, dir->N);
        } else {
            L->push();
        }
    }

    return r;
}

const cdutils::DirEntry * Luadirentry::getdir() {
    return dir;
}