#include <algorithm>
#include <map>
#include <vector>
#include <string>
#include <stdio.h>
#include <stdint.h>
#include "util/ReadWriter.h"
#include "util/rw/MmapReader.h"
// g++-mp-4.5 -std=c++0x iraqlog.cpp -I ../common -g -O0 -Wall
const char* processline(const char *first, const char *last, StringList& fields)
{
    const char *p= first;
    bool escaped= false;
    bool inquotes= false;
    std::string *str= NULL;
    while (p<last)
    {
        if (escaped) {
            *str += *p;
            escaped= false;
        }
        else if (inquotes) {
            if (*p=='"') {
                inquotes= false;
            }
            else if (*p=='\\') {
                escaped= true;
            }
            else {
                *str += *p;
            }
        }
        else if (*p==0x0a) {
            return p+1;
        }
        else {
            if (!str) {
                fields.resize(fields.size()+1);
                str= &fields.back();
            }
            if (*p=='"') {
                inquotes= true;
            }
            else if (*p==',')  {
                fields.resize(fields.size()+1);
                str= &fields.back();
            }
            else {
                *str += *p;
            }
        }
        p++;
    }
    return p;
}
int convertdigit(char c)
{
    if (c<'0') return -1;
    if (c<='9') return c-'0';
    if (c<'A') return -1;
    if (c<='Z') return c-'A'+10;
    if (c<'a') return -1;
    if (c<='z') return c-'a'+10;
    return -1;
}
bool getintfromstr(const char* first, const char* last, int base, int &number)
{
    number= 0;
    const char *p= first;
    while (p<last)
    {
        int digit= convertdigit(*p++);
        if (digit==-1 || digit>=base)
            return false;
        number *= base;
        number += digit;
    }

    return true;
}
// 0123456789abcd
// IRQyyyymmddnNN
bool datefromurl(const std::string& str, time_t &t, int &id)
{
    if (str.size()<13)
        return false;

    if (str[0]!='I' || str[1]!='R' || str[2]!='Q' || str[11]!='n')
        return false;

    struct tm tm;
    memset(&tm, 0, sizeof(tm));

    if (!getintfromstr(&str[3], &str[7], 10, tm.tm_year)
            || !getintfromstr(&str[7], &str[9], 10, tm.tm_mon)
            || !getintfromstr(&str[9], &str[11], 10, tm.tm_mday)
            || !getintfromstr(&str[12], str.c_str()+str.size(), 10, id)) {
        return false;
    }

    tm.tm_year-=1900;
    tm.tm_mon-=1;
    tm.tm_isdst= -1;

    t= mktime(&tm);
    return true;
}
// 0123456789abcdef012
// yyyy-mm-dd hh:mm:ss
bool datefromdate(const std::string& str, time_t &t)
{
    if (str.size()!=19)
        return false;

    if (str[4]!='-' || str[7]!='-' || str[13]!=':' || str[16]!=':')
        return false;

    struct tm tm;
    memset(&tm, 0, sizeof(tm));

    if (!getintfromstr(&str[0], &str[4], 10, tm.tm_year)
            || !getintfromstr(&str[5], &str[7], 10, tm.tm_mon)
            || !getintfromstr(&str[8], &str[10], 10, tm.tm_mday)
            || !getintfromstr(&str[11], &str[13], 10, tm.tm_hour)
            || !getintfromstr(&str[14], &str[16], 10, tm.tm_min)
            || !getintfromstr(&str[17], &str[19], 10, tm.tm_sec)) {
        return false;
    }
    if (tm.tm_sec) {
        printf("NOTE: date with sec!=0: %s\n", str.c_str());
    }

    tm.tm_year-=1900;
    tm.tm_mon-=1;
    tm.tm_isdst= -1;

    t= mktime(&tm);
    return true;
}
// 0123456789abcdef0
// yyyymmddhhmmssXXX
bool datefromtrackingnr_type1(const std::string& str, time_t &t, std::string& tag)
{
    if (str.size()!=17)
        return false;

    struct tm tm;
    memset(&tm, 0, sizeof(tm));

    if (!getintfromstr(&str[0], &str[4], 10, tm.tm_year)
            || !getintfromstr(&str[4], &str[6], 10, tm.tm_mon)
            || !getintfromstr(&str[6], &str[8], 10, tm.tm_mday)
            || !getintfromstr(&str[8], &str[10], 10, tm.tm_hour)
            || !getintfromstr(&str[10], &str[12], 10, tm.tm_min)) {
        return false;
    }

    tm.tm_year-=1900;
    tm.tm_mon-=1;
    tm.tm_isdst= -1;

    tag= str.substr(12);

    t= mktime(&tm);

    return true;
}
// 0123456789abcdef0123
// yyyy-DDD-hhmmss-NNNN   ( DDD = day of year )
bool datefromtrackingnr_type2(const std::string& str, time_t &t, int& id)
{
    if (str.size()!=20)
        return false;

    if (str[4]!='-' || str[8]!='-' || str[15]!='-')
        return false;
    struct tm tm;
    memset(&tm, 0, sizeof(tm));

    int yday= 0;
    if (!getintfromstr(&str[0], &str[4], 10, tm.tm_year)
            || !getintfromstr(&str[5], &str[8], 10, yday)
            || !getintfromstr(&str[9], &str[11], 10, tm.tm_hour)
            || !getintfromstr(&str[11], &str[13], 10, tm.tm_min)
            || !getintfromstr(&str[13], &str[15], 10, tm.tm_sec)
            || !getintfromstr(&str[16], str.c_str()+str.size(), 10, id)) {
        return false;
    }

    tm.tm_year-=1900;
    tm.tm_mon=0;
    tm.tm_mday=1;
    tm.tm_isdst= -1;


    t= mktime(&tm)+86400*(yday-1);

    return true;
}
std::string datestr(time_t t)
{
    struct tm tm= *localtime(&t);
    std::string str;
    str.resize(19);
    snprintf(&str[0], 20, "%04d-%02d-%02d %02d:%02d:%02d", tm.tm_year+1900, tm.tm_mon+1, tm.tm_mday, tm.tm_hour, tm.tm_min, tm.tm_sec);

    return str;
}
void processfile(const char *first, const char *last)
{
    typedef std::map<std::string, int> xref_t;
    typedef std::vector<xref_t> fieldxref_t;

    std::vector<unsigned> xrefids= {  4,  5, 10, 11, 14, 31, 32, 33 };

    const char *p= first;
    StringList fieldnames;
    if (p<last)
        p= processline(p, last, fieldnames);

    fieldxref_t xref(fieldnames.size());

    int linenr= 2;
    while (p<last)
    {
        StringList fields;
        p= processline(p, last, fields);
        if (fields.size()!=fieldnames.size())
            printf("%8d: %zd != %zd\n", linenr, fieldnames.size(), fields.size());

        if (!fields.empty()) {
            std::for_each(xrefids.begin(), xrefids.end(), [&xref, &fields](unsigned i) {
                xref[i][fields[i]]++;
            });

            int id=0;
            time_t t1=0;
            if (!datefromurl(fields[1], t1, id))
                printf("invalid url: [ url=%s, date=%s, track=%s ]\n", fields[1].c_str(), fields[3].c_str(), fields[6].c_str());
            time_t t3=0;
            if (!datefromdate(fields[3], t3))
                printf("invalid dat: [ url=%s, date=%s, track=%s ]\n", fields[1].c_str(), fields[3].c_str(), fields[6].c_str());
            std::string tag;
            int id6;
            time_t t6=0;
            if (!datefromtrackingnr_type1(fields[6], t6, tag)
                    && !datefromtrackingnr_type2(fields[6], t6, id6))
                printf("invalid trk: [ url=%s, date=%s, track=%s ]\n", fields[1].c_str(), fields[3].c_str(), fields[6].c_str());

            if (!tag.empty())
                xref[6][tag]++;

            printf("times %s  %s  %s : %9d %9d %9d   %4s %4s %4s %4s %4s %4s %4s %4s %4s\n", datestr(t1).c_str(), datestr(t3).c_str(), datestr(t6).c_str(),
                    (t3&&t1) ? int(t3-t1) : 0,
                    (t6&&t1) ? int(t6-t1) : 0,
                    (t6&&t3) ? int(t6-t3) : 0,
                    fields[15].c_str(), fields[16].c_str(), fields[17].c_str(),
                    fields[18].c_str(), fields[19].c_str(), fields[20].c_str(),
                    fields[21].c_str(), fields[22].c_str(), fields[23].c_str());
        }

        linenr++;
    }

    for (unsigned i=0 ; i<fieldnames.size() ; i++)
    {
        if (xref[i].empty()) {
            printf("field %2d : %s\n", i, fieldnames[i].c_str());
        }
    }
    for (unsigned i=0 ; i<fieldnames.size() ; i++)
    {
        if (!xref[i].empty()) {
            printf("field %2d : %s\n", i, fieldnames[i].c_str());
            std::for_each(xref[i].begin(), xref[i].end(), [](xref_t::value_type& p) {
                printf("%8d %s\n", p.second, p.first.c_str());
            });
        }
    }
}

int main(int argc, char**argv)
{
    if (argc!=2)
        return 1;
    try {
    MmapReader r(argv[1], MmapReader::readonly);

    processfile((const char*)r.begin(), (const char*)r.end());
    }
    catch(...)
    {
        printf("ERROR\n");
        return 1;
    }
    return 0;
}


// ~/cvsprj/xda-devtools/dumprom/cpp_editimgfs.cpp:        MmapReader rl(arg.substr(1), MmapReader::readonly);
// ~/cvsprj/xda-devtools/dumprom/cpp_editimgfs.cpp:            (readonly ? new MmapReader(imgname, MmapReader::readonly)
// ~/cvsprj/xda-devtools/dumprom/cpp_editimgfs.cpp:                     : new MmapReader(imgname, MmapReader::readwrite));
// ~/cvsprj/xda-devtools/itsutils/src/checkdll.cpp:    MmapReader src(srcfile, MmapReader::readonly);
// ~/cvsprj/xda-devtools/itsutils/src/dump.cpp://    * use MmapReader/FileReader/BlockDevice where appropriate
// ~/cvsprj/xda-devtools/itsutils/src/findimg.cpp:    MmapReader r(path, MmapReader::readonly);
// ~/cvsprj/xda-devtools/itsutils/src/findimg.cpp:        MmapReader rl(arg.substr(1), MmapReader::readonly);
// ~/cvsprj/xda-devtools/itsutils/src/getsigningcert.cpp:        MmapReader rl(arg.substr(1), MmapReader::readonly);
// ~/cvsprj/xda-devtools/itsutils/src/ntfsrd.cpp:        f.reset(new MmapReader(devname, MmapReader::readonly));
// ~/cvsprj/xda-devtools/itsutils/src/xrefbytes.cpp:    MmapReader file(filename, MmapReader::readonly);