#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#include <scriptpp/scrvar.hpp>
#include <scriptpp/scrvect.hpp>
#include <scriptpp/scrmsg.hpp>
#include <scriptpp/cmd.hpp>


#include "database.hpp"
#include "main_all.hpp"

#include "main_upd.hpp"

#define FILESPEC_TEXT\
    "The <filespec> may be either a file path or a Thalassa object\n"\
    "specification.  In case the argument contains at least one ``/'',\n"\
    "it is taken as a path to an existing file; the Thalassa database\n"\
    "is not even loaded in this case.  If the argument contains at\n"\
    "least one ``='', it is considered to be a Thalassa object\n"\
    "specification, which must either specify a pageset page ID,\n"\
    "or a comment ID for either a list item page, or a pageset page.\n"\
    "In case there's neither a ``/'' nor a ``='' in the argument\n"\
    "(which is not recommended, it is better to use ./name for files\n"\
    "and setID=pgID for pageset pages), Thalassa will first try a\n"\
    "file in the current working directory, and if there's no such\n"\
    "file or it is not a regular file, will try to load the database\n"\
    "and use the given name as a pageset page ID (which only works if\n"\
    "you've got exactly one pageset).\n"\
    "\n"\
    "Thalassa object specifications have the form\n"\
    "\n"\
    "    [<type>=[<realmID>=]]<pageID>[=<commentID>]\n"\
    "\n"\
    "where <type> is one of ``list'', ``set'' or ``pageset'' (the\n"\
    "latter two are equal), but is in most cases simply omitted;\n"\
    "<realmID> is an ID of either a list or a pageset;\n"\
    "<pageID> is either a pageset page ID, or an item ID within\n"\
    "a list with item pages;\n"\
    "<commentID> is, well, the comment ID.\n"\
    "Please note that in case the <commentID> is omitted, then the\n"\
    "type must not be ``list'' and the realmID must not be a list ID\n"\
    "because list item pages don't have source files, and this command\n"\
    "is only intended to work with headed text files.  The <realmID> may\n"\
    "only be omitted in case you only have one realm: either exactly one\n"\
    "pageset and no lists, or no pagesets and exactly one list.  If you\n"\
    "specify a pair like XXX=YYY, it is considered to be pageID=commentID\n"\
    "if and only if you have exactly one realm, otherwise it is\n"\
    "interpreted as setID=pageID.\n"


void help_update(FILE *stream)
{
    fprintf(stream,
        "The ``update'' command updates a ``headed text'' (page/comment) file."
                                                                           "\n"
        "Usage:\n"
        "\n"
        "    thalassa [...] update <filespec> [<options>]\n"
        "\n"
        FILESPEC_TEXT
        "\n"
        "Valid options are:\n"
        "\n"
        "    -n             dry run: show what would be done but don't do\n"
        "    +T <tag>       add the tag\n"
        "    -T <tag>       remove the tag\n"
        "    +F <flag>      add the flag\n"
        "    -F <flag>      remove the flag\n"
        "    +L <label>     add the label\n"
        "    -L <label>     remove the label\n"
        "    -D <unixtime>  use the <unixtime> instead of the current time\n"
        "    -d             force updating the ``unixtime:'' field:\n"
        "                     update even if it is already there\n"
        "    -t             update the ``teaser_len:'' field: if there's no\n"
        "                     ``descr:'' field, search the body for the\n"
        "                     ``<!--break-->'' string and put its position\n"
        "                     into the field, or put the length body if the\n"
        "                     string isn't found; if the ``descr:'' field\n"
        "                     is there, just remove the ``teaser_len:''\n"
        "    -i             suppress updating of the ``id:'' field\n"
        "                     by default, it is set accordingly to the\n"
        "                     object specification or file path\n"
        "    -b <suffix>    set the backup file suffix (default: ``~'')\n"
        "    -B             don't create backup files\n"
        "    -v             verbose messages\n"
        "\n"
    );
}

enum file_types { ft_guess, ft_page, ft_comment };

struct file_choice {
    ScriptVariableInv filename, id;
    int file_type;
    file_choice() : file_type(ft_guess) {}
};

enum task_categories { ct_label, ct_flag, ct_tag };

struct Task {
    int category;
    bool add;   // false to remove
    ScriptVariable name;
    Task *next;
    Task(int c, bool a, const ScriptVariable &n)
        : category(c), add(a), name(n), next(0) {}
};

struct cmdline_update : public file_choice {
    Task *first, *last;
    bool dry_run;
    ScriptVariable baksuffix;
    bool backup;
    long long date;
    bool force_date_update;
    bool teaser_update;
    bool dont_touch_id;
    bool verbose;
    cmdline_update()
        : first(0), last(0), dry_run(false),
        baksuffix("~"), backup(true), date(0), force_date_update(false),
        teaser_update(false), dont_touch_id(false), verbose(false)
    {}
    ~cmdline_update();
    void AddTask(int c, bool a, const ScriptVariable &n);
};

cmdline_update::~cmdline_update()
{
    while(first) {
        Task *tmp = first;
        first = first->next;
        delete tmp;
    }
}

void cmdline_update::AddTask(int c, bool a, const ScriptVariable &n)
{
    Task *p = new Task(c, a, n);
    if(last)
        last->next = p;
    else
        first = p;
    last = p;
}

const char *headername(int c)
{
    switch(c) {
    case ct_label: return "label";
    case ct_flag:  return "flags";
    case ct_tag:   return "tags";
    }
    // we shouln't have reached this point!
    fprintf(stderr, "BUG: unknown header code\n");
    exit(5);
}

static int action_by_char(char c)
{
    switch(c) {
    case 'L':   return ct_label;
    case 'F':   return ct_flag;
    case 'T':   return ct_tag;
    default:    return -1;   /* shouldn't happen */
    }
}


    // the file name (or object spec) is already not there
static bool
parse_update_cmdl(int argc, const char *const *argv, cmdline_update &options)
{
    const char *const *p = argv;
    while(*p) {
        if(((*p)[0] == '+' || (*p)[0] == '-') &&
            ((*p)[1] == 'T' || (*p)[1] == 'F' || (*p)[1] == 'L') &&
            ((*p)[2] == 0))
        {
            if(!p[1]) {
                fprintf(stderr, "action requires a parameter\n");
                return false;
            }
            options.AddTask(action_by_char((*p)[1]), (*p)[0] == '+', p[1]);
            p += 2;
            continue;
        }
        if((*p)[0] == '-') {
            if((*p)[1] == 0 || (*p)[2] != 0) {
                fprintf(stderr, "option %s unknown\n", *p);
                return false;
            }
            switch((*p)[1]) {
            case 'b':
                if(!p[1]) {
                    fprintf(stderr, "-b requires a parameter\n");
                    return false;
                }
                options.baksuffix = p[1];
                p += 2;
                break;
            case 'D':
                if(!p[1]) {
                    fprintf(stderr, "-D requires a parameter\n");
                    return false;
                }
                {   // to localize vars
                    long long d;
                    bool ok = ScriptVariable(p[1]).GetLongLong(d, 10);
                    if(!ok || d < 1) {
                        fprintf(stderr, "invalid date ``%s''\n", p[1]);
                        return false;
                    }
                    options.date = d;
                }
                p += 2;
                break;
            case 'B':
                options.backup = false;
                p++;
                break;
            case 'n':
                options.dry_run = true;
                p++;
                break;
            case 'd':
                options.force_date_update = true;
                p++;
                break;
            case 't':
                options.teaser_update = true;
                p++;
                break;
            case 'i':
                options.dont_touch_id = true;
                p++;
                break;
            case 'v':
                options.verbose = true;
                p++;
                break;
            default:
                fprintf(stderr, "option %s unknown\n", *p);
                return false;
            }
            continue;
        }
        if((*p)[0] == '+') {
            fprintf(stderr, "action %s unknown\n", *p);
            return false;
        }
        fprintf(stderr, "extra argument(s) starting with %s\n", *p);
        return false;
    }
    return true;
}

//////////////////////////////////////////////////////////////////////

static bool svec_has_elem(const ScriptVector &v, const ScriptVariable &el)
{
    int i;
    for(i = 0; i < v.Length(); i++) {
        if(v[i] == el)
            return true;
    }
    return false;
}

static bool get_fname_setitem(Database &dbs,
                 const ScriptVariable &set_id, const ScriptVariable &page_id,
                 file_choice &choice)
{
    const char *sid = set_id.c_str();
    bool ok;
    PageSetData sd;
    ok = dbs.GetSetData(set_id, sd);
    if(!ok) {
        fprintf(stderr, "%s: no such pageset or can't load\n", sid);
        return false;
    }
    ScriptVariable srcd, srcf;
    bool separdir;
    ok = dbs.GetSetItemSource(set_id, page_id, srcd, srcf, separdir);
    if(!ok) {
        fprintf(stderr, "%s=%s: can't find pageset item source file\n",
                        sid, page_id.c_str());
        return false;
    }
    choice.filename = srcf;
    choice.file_type = ft_page;
    choice.id = page_id;
    return true;
}

static bool get_fname_listitem(Database &dbs,
                 const ScriptVariable &list_id, const ScriptVariable &page_id,
                 file_choice &choice)
{
    ListData ld;
    const char *lid = list_id.c_str();
    bool ok = dbs.GetListData(list_id, ld);
    if(!ok) {
        fprintf(stderr, "%s: no such list or can't load\n", lid);
        return false;
    }
    if(ld.srctype != listsrc_set) {
        fprintf(stderr,
                "%s: list is not set-based, can't update its items\n", lid);
        return false;
    }
    return get_fname_setitem(dbs, ld.srcname, page_id, choice);
}

static bool get_fname_li(Database &dbs, const ScriptVariable &comconf,
                         ListItemData &li, ScriptVariable cmt_id,
                         file_choice &choice)
{
    dbs.SetMacroData(0, &li);
    ScriptVariable path = dbs.GetCommentsPath(comconf);
    dbs.ForgetMacroData();
    if(path.IsInvalid())
        return false;
    path.Trim();
    while(cmt_id.Length() < 4)
        cmt_id.Range(0, 0).Replace("0");
    if(path.Range(-1, 1)[0] != '/')
        path += "/";
    choice.filename = path + cmt_id;
    choice.file_type = ft_comment;
    choice.id = cmt_id;
    return true;
}

static bool get_fname_setcmt(Database &dbs, const ScriptVariable &set_id,
                 const ScriptVariable &page_id, const ScriptVariable &cmt_id,
                 file_choice &choice)
{
    const char *sid = set_id.c_str();
    bool ok;
    PageSetData sd;
    ok = dbs.GetSetData(set_id, sd);
    if(!ok) {
        fprintf(stderr, "%s: no such pageset or can't load\n", sid);
        return false;
    }
    if(sd.comments_conf.IsInvalid() || sd.comments_conf == "") {
        fprintf(stderr, "%s: comments not configured for the set\n", sid);
        return false;
    }

    ListItemData li;
    ok = dbs.GetSetItemDataById(set_id, page_id, &li);
    if(!ok) {
        fprintf(stderr, "%s: no such item in the pageset ``%s''\n",
                page_id.c_str(), sid);
        return false;
    }
    return get_fname_li(dbs, sd.comments_conf, li, cmt_id, choice);
}

static bool get_fname_listcmt(Database &dbs, const ScriptVariable&list_id,
                 const ScriptVariable &page_id, const ScriptVariable &cmt_id,
                 file_choice &choice)
{
    const char *lid = list_id.c_str();
    bool ok;
    ListData ld;
    ok = dbs.GetListData(list_id, ld);
    if(!ok) {
        fprintf(stderr, "%s: no such list or can't load\n", lid);
        return false;
    }
    if(ld.srctype == listsrc_set)
        return get_fname_setcmt(dbs, ld.srcname, page_id, cmt_id, choice);
    if(!ld.pages) {
        fprintf(stderr, "%s: list has no item pages\n", lid);
        return false;
    }
    if(ld.comments_conf.IsInvalid() || ld.comments_conf == "") {
        fprintf(stderr, "%s: comments not configured for the list\n", lid);
        return false;
    }

    int idx = -1;
    int max = ld.items.Length();
    int i;
    for(i = 0; i < max; i++) {
        if(ld.items[i] == page_id) {
            idx = i;
            break;
        }
    }
    if(idx == -1) {
        fprintf(stderr, "%s: no such item in the list ``%s''\n",
                page_id.c_str(), lid);
        return false;
    }
    ListItemData li;
    ok = dbs.GetListItemData(ld, idx, li);
    if(!ok) {
        fprintf(stderr, "%s=%s: couldn't load the list item data\n",
                lid, page_id.c_str());
        return false;
    }
    return get_fname_li(dbs, ld.comments_conf, li, cmt_id, choice);
}

static ScriptVariable guess_id_from_fname(const ScriptVariable &fname)
{
    ScriptVector pparts(fname, "/", "");
    ScriptVariable last = pparts[pparts.Length()-1];
    if(last == PAGESET_MAIN_FILE_NAME)
        return pparts[pparts.Length()-2];
    if(last.Length() == 4) {
        long n;
        bool num = last.GetLong(n, 10);
        if(num)
           return ScriptNumber(num);
    }
    if(last == "" || last == "." || last == "..")
        return ScriptVariableInv();
    return last;
}

static bool choose_filename(cmdline_common &cmd_com, const char *name_str,
                                             file_choice &choice)
{
    ScriptVariable name(name_str);
    if(name.Strchr('/').IsValid()) {
        choice.filename = name;
        choice.id = guess_id_from_fname(name);
        return true;
    }
    if(name.Strchr('=').IsInvalid()) {   // no ``/'', no ``=''
        FileStat fs(name.c_str());
        if(fs.Exists() && fs.IsRegularFile()) {
            choice.filename = name;
            return true;
        }
    }
    Database database;
    bool ok;
    ok = load_inifiles(database, cmd_com.inifiles, cmd_com.opt_selector);
    if(!ok)
        return false;
    ScriptVector vect(name, "=", "");
    int vlen = vect.Length();
    if(vlen < 1)       // nonsense, but technically possible (empty param)
        return false;
    if(vlen == 1) {    // very special case, partially handled above
        // it must be a pageset page ID, and there must be only one pageset
        ScriptVector sets;
        database.GetSets(sets);
        if(sets.Length() < 1) {
            fprintf(stderr, "there are no page sets\n");
            return false;
        }
        if(sets.Length() > 1) {
            fprintf(stderr,
                    "there are more than one page sets, specify the ID\n");
            return false;
        }
        return get_fname_setitem(database, sets[0], vect[0], choice);
    }
    if(vlen == 2) {   // setID=pageID or pageID=cmtID (if there's 1 realm)
        ScriptVector sets, lists;
        database.GetSets(sets);
        database.GetLists(lists);
        // check if there's one realm
        if(sets.Length() == 0 && lists.Length() == 1)
            return get_fname_listcmt(database, lists[0], vect[0], vect[1],
                                     choice);
        if(sets.Length() == 1 && lists.Length() == 0)
            return get_fname_setcmt(database, sets[0], vect[0], vect[1],
                                     choice);
        // more than one realm (or none at all? n/p, will fail later)
        return get_fname_setitem(database, vect[0], vect[1], choice);
    }
    // 3, 4
    if(vect[0] == "list") {
        if(vlen == 3)
            return get_fname_listitem(database, vect[1], vect[2], choice);
        else
            return get_fname_listcmt(database, vect[1], vect[2], vect[3],
                                     choice);
    }
    if(vect[0] == "set" || vect[0] == "pageset") {
        if(vlen == 3)
            return get_fname_setitem(database, vect[1], vect[2], choice);
        else
            return get_fname_setcmt(database, vect[1], vect[2], vect[3],
                                    choice);
    }
    if(vlen > 3) {
        fprintf(stderr, "realm type ``%s'' unknown\n", vect[0].c_str());
        return false;
    }
    // exactly 3 tokens, must be realmID=pageID=cmtID
    // now we need to guess the realm type
    ScriptVector sets, lists;
    database.GetSets(sets);
    database.GetLists(lists);
    bool may_be_set = svec_has_elem(sets, vect[0]);
    bool may_be_list = svec_has_elem(lists, vect[0]);
    if(may_be_list && may_be_set) {
        fprintf(stderr,
                "both list and set named ``%s'' exist, give the realm type\n",
                vect[0].c_str());
        return false;
    }
    if(may_be_list)
        return get_fname_listcmt(database, vect[0], vect[1], vect[2], choice);
    if(may_be_set)
        return get_fname_setcmt(database, vect[0], vect[1], vect[2], choice);
    // neither?
    fprintf(stderr, "there's no list nor set named ``%s''\n", vect[0].c_str());
    return false;
}

//////////////////////////////////////////////////////////////////////

static void print_headers(const HeadedTextMessage &parser, FILE *stream)
{
    const ScriptVector &h = parser.GetHeaders();
    int len = h.Length();
    int i;
    for(i = 0; i < len; i += 2)
        fprintf(stream, "%s: %s\n", h[i].c_str(), h[i+1].c_str());
}

//////////////////////////////////////////////////////////////////////

static void perform_single_task(Task *task, HeadedTextMessage &parser,
                                const cmdline_update &opts)
{
    const char *hname = headername(task->category);
    ScriptVector &hdr = parser.GetHeaders();
    bool found = false;
    int i;
    for(i = 0; i < hdr.Length(); i += 2)
        if(hdr[i] == hname) {
            found = true;
            break;
        }
    if(!found) {  // trivial case
        if(task->add) {
            hdr.AddItem(hname);
            hdr.AddItem(task->name);
        } else {
            // actually, nothing to do: can't remove anything
            // from an empty list
        }
        return;
    }
    ScriptVector v(hdr[i+1], ",", " \t\r");
    int pos = -1;
    int j;
    for(j = 0; j < v.Length(); j++)
        if(v[j] == task->name) {
            pos = j;
            break;
        }

    if(task->add) {
        if(pos != -1)   // already there!
            return;
        v.AddItem(task->name);
    } else {
        if(pos == -1)   // not there, can't remove
            return;
        v.Remove(pos, 1);
    }
    // if we're here, we should reconstruct the changed header
    if(v.Length() == 0)   // empty? simply remove the header altogether
        hdr.Remove(i, 2);
    else
        hdr[i+1] = v.Join(", ");
}

static void
do_update_unixtime(const cmdline_update &opts, HeadedTextMessage &parser)
{
    if(!opts.force_date_update) {
        ScriptVariable orig = parser.FindHeader("unixtime");
        if(orig.IsValid() && orig != "")
            return;
    }
    long long tm = opts.date > 1 ? opts.date : time(0);
    parser.SetHeader("unixtime", ScriptNumber(tm));
}

static void do_update_teaser(HeadedTextMessage &parser)
{
    ScriptVariable descr = parser.FindHeader("descr");
    if(descr.IsValid() && descr != "") {
        parser.RemoveHeader("teaser_len");
        return;
    }
    ScriptVariable &body = parser.GetBody();
    ScriptVariable::Substring pos = body.Strstr("<!--break-->");
    int x = pos.IsValid() ? pos.Index() : body.Length();
    parser.SetHeader("teaser_len", ScriptNumber(x));
}

static bool proceed_update_headedtext(const cmdline_update &opts)
{
    const char *fp = opts.filename.c_str();
    FILE *s = fopen(fp, "r");
    if(!s) {
        perror(fp);
        return false;
    }
    HeadedTextMessage parser;
    int c;
    while((c = fgetc(s)) != EOF) {
        if(!parser.FeedChar(c))   // int, ok
            break;
    }
    fclose(s);

    if(opts.dry_run || opts.verbose) {
        fprintf(stderr, "== header fields before changes ==============\n");
        print_headers(parser, stderr);
    }

    do_update_unixtime(opts, parser);
    if(!opts.dont_touch_id) {
        if(opts.id.IsValid() && opts.id != "")
            parser.SetHeader("id", opts.id);
        else
            fprintf(stderr, "WARNING: couldn't guess the id, not updated\n");
    }
    if(opts.teaser_update)
        do_update_teaser(parser);

    Task *p;
    for(p = opts.first; p; p = p->next)
        perform_single_task(p, parser, opts);

    if(opts.dry_run || opts.verbose) {
        fprintf(stderr, "== header fields after changes ===============\n");
        print_headers(parser, stderr);
        fprintf(stderr, "==============================================\n");
    }
    if(opts.dry_run) {
        fprintf(stderr, "NOTICE: dry run, not updating any files\n");
        return true;
    }

    if(opts.backup) {
        int r = rename(fp, (opts.filename + opts.baksuffix).c_str());
        if(r == -1) {
            perror((opts.filename + opts.baksuffix).c_str());
            fprintf(stderr, "couldn't backup old version, aborting\n");
            return false;
        }
    }

    // save parser to file
    s = fopen(fp, "w");
    if(!s) {
        perror(fp);
        return false;
    }
    ScriptVariable nc = parser.Serialize();
    fputs(nc.c_str(), s);
    fclose(s);
    return true;
}

//////////////////////////////////////////////////////////////////////

int perform_update(cmdline_common &cmd_com, int argc, const char * const *argv)
{
    if(argc < 2) {
        fprintf(stderr, "``update'' requires args, try ``help update''\n");
        return 1;
    }

    cmdline_update opts;
    bool ok;
    ok = choose_filename(cmd_com, argv[1], opts);
    if(!ok)
        return 1;
    ok = parse_update_cmdl(argc - 2, argv + 2, opts);
    if(!ok)
        return 1;
    if(opts.dry_run || opts.verbose)
        fprintf(stderr, "NOTICE: file '%s' selected\n", opts.filename.c_str());
    ok = proceed_update_headedtext(opts);
    if(!ok)
        return 1;
    return 0;
}



//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////

void help_inspect(FILE *stream)
{
    fprintf(stream,
        "The ``inspect'' command prints a ``headed text'' file header\n"
        "and optionally some lines of its body.  Usage:\n"
        "\n"
        "    thalassa [...] inspect <filespec> [<options>]\n"
        "\n"
        FILESPEC_TEXT
        "\n"
        "Valid options are:\n"
        "\n"
        "    -b <n>         show the first <n> lines of the body\n"
        "    -B             show the whole body\n"
        "    -v             verbose messages\n"
        "\n"
    );
}

struct cmdline_inspect : public file_choice {
    int lines;
    bool whole_body, verbose;
    cmdline_inspect() : lines(0), whole_body(false), verbose(false) {}
};

    // the file name (or object spec) is already not there
static bool
parse_inspect_cmdl(int argc, const char *const *argv, cmdline_inspect &options)
{
    const char *const *p = argv;
    while(*p) {
        if((*p)[0] == '-') {
            if((*p)[1] == 0 || (*p)[2] != 0) {
                fprintf(stderr, "option %s unknown\n", *p);
                return false;
            }
            switch((*p)[1]) {
            case 'b':
                if(!p[1]) {
                    fprintf(stderr, "-b requires a parameter\n");
                    return false;
                }
                {   // to localize vars
                    long n;
                    bool ok = ScriptVariable(p[1]).GetLong(n, 10);
                    if(!ok || n < 0) {
                        fprintf(stderr, "invalid number ``%s''\n", p[1]);
                        return false;
                    }
                    options.lines = n;
                }
                p += 2;
                break;
            case 'B':
                options.whole_body = true;
                p++;
                break;
            case 'v':
                options.verbose = true;
                p++;
                break;
            default:
                fprintf(stderr, "option %s unknown\n", *p);
                return false;
            }
            continue;
        }
        fprintf(stderr, "extra argument(s) starting with %s\n", *p);
        return false;
    }
    return true;
}

int perform_inspect(cmdline_common &cmd_com, int argc, const char *const *argv)
{
    if(argc < 2) {
        fprintf(stderr, "``inspect'' requires args, try ``help inspect''\n");
        return 1;
    }

    cmdline_inspect options;
    bool ok;
    ok = choose_filename(cmd_com, argv[1], options);
    if(!ok)
        return 1;
    ok = parse_inspect_cmdl(argc - 2, argv + 2, options);
    if(!ok)
        return 1;
    if(options.verbose)
        fprintf(stderr, "NOTICE: file '%s' selected\n",
                        options.filename.c_str());

    const char *fp = options.filename.c_str();
    FILE *s = fopen(fp, "r");
    if(!s) {
        perror(fp);
        return false;
    }
    HeadedTextMessage parser;
    int c;
    while((c = fgetc(s)) != EOF) {
        if(!parser.FeedChar(c))   // int, ok
            break;
    }
    fclose(s);

    print_headers(parser, stdout);
    fputc('\n', stdout);

    int lines = 0;
    const char *b = parser.GetBody().c_str();
    while(*b && (lines < options.lines || options.whole_body)) {
        fputc(*b, stdout);
        if(*b == '\n')
            lines++;
        b++;
    }

    return 0;
}