/* Copyright (c) 2019, Anthony Latorre <tlatorre at uchicago>
 *
 * 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 3 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, see <https://www.gnu.org/licenses/>.
 */

#include <stdio.h>
#include "zebra.h"
#include "event.h"
#include "zdab_utils.h"
#include "pmt.h"
#include "db.h"
#include "dqxx.h"
#include <inttypes.h> /* for PRIu32 macro */
#include <string.h> /* for memcpy() */
#include <errno.h> /* for errno */
#include "release.h"
#include "dc.h"

#define EV_RECORD      0x45562020 // 'EV  '
#define MCTK_RECORD    0x4d43544b // 'MCTK'
#define MCVX_RECORD    0x4d435658 // 'MCVX'

char *GitSHA1(void);
char *GitDirty(void);

void usage(void)
{
    fprintf(stderr,"Usage: ./zdab-cat [options] FILENAME\n");
    fprintf(stderr,"  -o      output file (default: stdout)\n");
    fprintf(stderr,"  --skip-second-event  only fit the first event after a MAST bank\n");
    fprintf(stderr,"  -h      display this help message\n");
    exit(1);
}

int main(int argc, char **argv)
{
    int i;
    zebraFile *f;
    zebraBank bmast, bmc, bmcgn, mctk, b;
    int rv;
    EVBank bev;
    FTPVBank bftpv;
    FTXKBank bftxk;
    RSPBank bftxr;
    MCTKBank bmctk;
    MCVXBank bmcvx;
    event ev = {0};
    char *filename = NULL;
    char *output = NULL;
    FILE *fout = stdout;
    int skip_second_event = 0;
    size_t nhit;
    int last_run;
    char dqxx_file[256];

    for (i = 1; i < argc; i++) {
        if (strlen(argv[i]) >= 2 && !strncmp(argv[i], "--", 2)) {
            if (!strcmp(argv[i]+2,"skip-second-event")) {
                skip_second_event = 1;
                continue;
            }
        } else if (argv[i][0] == '-') {
            switch (argv[i][1]) {
            case 'o':
                output = argv[++i];
                break;
            case 'h':
                usage();
            default:
                fprintf(stderr, "unrecognized option '%s'\n", argv[i]);
                exit(1);
            }
        } else {
            filename = argv[i];
        }
    }

    if (!filename)
        usage();

    f = zebra_open(filename);

    if (!f) {
        fprintf(stderr, "%s\n", zebra_err);
        return 1;
    }

    if (output) {
        fout = fopen(output, "w");

        if (!fout) {
            fprintf(stderr, "failed to open '%s': %s\n", output, strerror(errno));
            return 1;
        }
    }

    if (fout) {
        fprintf(fout, "git_sha1: %s\n", GitSHA1());
        fprintf(fout, "git_dirty: %s\n", GitDirty());
    }

    if (load_pmt_info()) {
        zebra_close(f);
        if (output) fclose(fout);
        return 1;
    }

    for (i = 0; i < MAX_PMTS; i++) {
        ev.pmt_hits[i].hit = 0;
        ev.pmt_hits[i].flags = 0;
    }

    ev.run = -1;

    dict *db = db_init();

    last_run = 10000;

    if (load_file(db, "DQXX_0000010000.dat", 0)) {
        fprintf(stderr, "failed to load DQXX_0000010000.dat: %s\n", db_err);
        goto err;
    }

    if (dqxx_init(db, &ev)) {
        fprintf(stderr, "failed to initialize DQXX bank: %s\n", dqxx_err);
        goto err;
    }

    while (1) {
        rv = zebra_read_next_logical_record(f);

        if (rv == -1) {
            fprintf(stderr, "error getting logical record: %s\n", zebra_err);
            goto err;
        } else if (rv == 1) {
            /* EOF */
            break;
        }

        rv = zebra_get_bank(f, &bmast, f->first_bank);

        if (rv) {
            fprintf(stderr, "error getting MAST bank: %s\n", zebra_err);
            goto err;
        }

        if (bmast.links[KMAST_EV-1] == 0) {
            /* First logical record in SNOCR files doesn't have an EV bank. */
            continue;
        }

        if (fout) fprintf(fout, "---\n");

        if (bmast.links[KMAST_MC-1] == 0) goto skip_mc;

        rv = zebra_get_bank(f,&bmc,bmast.links[KMAST_MC-1]);

        if (rv) {
            fprintf(stderr, "error getting MC bank: %s\n", zebra_err);
            goto err;
        }

        if (bmast.links[KMC_MCGN-1] == 0) {
            fprintf(stderr, "MCGN link is zero!\n");
            goto err;
        }

        rv = zebra_get_bank(f,&bmcgn,bmc.links[KMC_MCGN-1]);

        if (rv) {
            fprintf(stderr, "error getting MCGN bank: %s\n", zebra_err);
            goto err;
        }

        if (fout) fprintf(fout, "    mcgn:\n");
        while (1) {
            if (bmcgn.links[KMCGN_MCTK-1] == 0) {
                fprintf(stderr, "MCTK link is zero!\n");
                goto err;
            }

            rv = zebra_get_bank(f,&mctk,bmcgn.links[KMCGN_MCTK-1]);

            if (rv) {
                fprintf(stderr, "error getting MCTK bank: %s\n", zebra_err);
                goto err;
            }

            if (mctk.orig == mctk.up - KMCVX_MCTK) {
                /* This is the first MCTK bank. */
                unpack_mctk(mctk.data, &bmctk);
            } else {
                /* For some reason SNOMAN sometimes links to the second MCTK
                 * from the MCGN bank. */
                rv = zebra_get_bank(f,&b,mctk.orig);

                if (b.idh != MCTK_RECORD) {
                    fprintf(stderr, "error following origin link from MCTK bank!\n");
                    goto err;
                }

                if (rv) {
                    fprintf(stderr, "error getting MCTK bank: %s\n", zebra_err);
                    goto err;
                }

                unpack_mctk(b.data, &bmctk);
            }

            if (mctk.up == 0) {
                fprintf(stderr, "MCVX link is zero!\n");
                goto err;
            }

            rv = zebra_get_bank(f,&b,mctk.up);

            if (rv) {
                fprintf(stderr, "error getting MCVX bank: %s\n", zebra_err);
                goto err;
            }

            unpack_mcvx(b.data, &bmcvx);

            if (fout) {
                fprintf(fout, "      -\n");
                fprintf(fout, "        id: %" PRIu32 "\n", bmctk.idp);
                fprintf(fout, "        energy: %.2f\n", bmctk.ene);
                fprintf(fout, "        posx: %.2f\n", bmcvx.x);
                fprintf(fout, "        posy: %.2f\n", bmcvx.y);
                fprintf(fout, "        posz: %.2f\n", bmcvx.z);
                fprintf(fout, "        dirx: %.4f\n", bmctk.drx);
                fprintf(fout, "        diry: %.4f\n", bmctk.dry);
                fprintf(fout, "        dirz: %.4f\n", bmctk.drz);
                fprintf(fout, "        time: %.4f\n", bmcvx.tim);
            }

            if (bmcgn.next) {
                rv = zebra_get_bank(f,&bmcgn,bmcgn.next);

                if (rv) {
                    fprintf(stderr, "error getting MCGN bank: %s\n", zebra_err);
                    goto err;
                }
            } else {
                break;
            }
        }

skip_mc:

        rv = zebra_get_bank(f,&b,bmast.links[KMAST_EV-1]);

        if (rv) {
            fprintf(stderr, "error getting EV bank: %s\n", zebra_err);
            goto err;
        }

        /* Skip to the last event so we can traverse them in reverse order. The
         * reason for this is that for some reason SNOMAN puts the events in
         * reverse order within each logical record. */
        while (b.next) {
            rv = zebra_get_bank(f,&b,b.next);

            if (rv) {
                fprintf(stderr, "error getting EV bank: %s\n", zebra_err);
                goto err;
            }
        }

        if (fout) fprintf(fout, "    ev:\n");
        while (1) {
            unpack_ev(b.data, &bev);
            ev.run = bev.run;
            ev.gtid = bev.gtr_id;
            ev.trigger_type = bev.trg_type;
            ev.trigger_time = bev.gtr;

            if (ev.run != last_run) {
                fprintf(stderr, "loading DQXX file for run %010i\n", ev.run);

                sprintf(dqxx_file, "DQXX_%010i.dat", ev.run);
                if (load_file(db, dqxx_file, 1)) {
                    fprintf(stderr, "failed to load %s: %s\n", dqxx_file, db_err);
                    goto err;
                }

                if (dqxx_init(db, &ev)) {
                    fprintf(stderr, "failed to initialize DQXX bank: %s\n", dqxx_err);
                    goto err;
                }

                last_run = ev.run;
            }

            rv = get_event(f,&ev,&b);

            nhit = get_nhit(&ev);

            if (fout) {
                fprintf(fout, "      - run: %i\n", ev.run);
                fprintf(fout, "        gtr: %.0f\n", ev.trigger_time);
                fprintf(fout, "        nhit: %zu\n", nhit);
                fprintf(fout, "        gtid: %i\n", ev.gtid);
                fprintf(fout, "        trg_type: 0x%08x\n", ev.trigger_type);
                fprintf(fout, "        dc: 0x%08x\n", get_dc_word(&ev, f, &bmast, &b));
            }

            if (fout) {
                if (get_ftpv(f,&b,&bftpv)) {
                    fprintf(stderr, "%s\n", zdab_err);
                } else {
                    fprintf(fout, "        ftp:\n");
                    fprintf(fout, "            x: %.2f\n", bftpv.x);
                    fprintf(fout, "            y: %.2f\n", bftpv.y);
                    fprintf(fout, "            z: %.2f\n", bftpv.z);
                }
            }

            if (fout) {
                if (get_ftxk(f,&b,&bftxk)) {
                    fprintf(stderr, "%s\n", zdab_err);
                } else {
                    fprintf(fout, "        ftk:\n");
                    fprintf(fout, "            energy: %.2f\n", bftxk.energy);
                }
            }

            if (fout) {
                if (get_rsp(f,&b,&bftxr)) {
                    fprintf(stderr, "%s\n", zdab_err);
                } else {
                    fprintf(fout, "        rsp:\n");
                    fprintf(fout, "            energy: %.2f\n", bftxr.ene);
                }
            }

            /* Note the origin link for the first EV bank points back to the
             * structural link location in the MAST bank. These links are super
             * confusing! */
            if ((b.orig == f->first_bank - KMAST_EV) || skip_second_event) break;

            rv = zebra_get_bank(f,&b,b.orig);

            if (rv) {
                fprintf(stderr, "error getting EV bank: %s\n", zebra_err);
                goto err;
            }
        }
    }

    db_free(db);

    if (fout) fclose(fout);

    zebra_close(f);

    return 0;

err:
    db_free(db);

    if (fout) fclose(fout);

    zebra_close(f);

    return 1;
}
 id='n257' href='#n257'>257</a>
<a id='n258' href='#n258'>258</a>
<a id='n259' href='#n259'>259</a>
<a id='n260' href='#n260'>260</a>
<a id='n261' href='#n261'>261</a>
<a id='n262' href='#n262'>262</a>
<a id='n263' href='#n263'>263</a>
<a id='n264' href='#n264'>264</a>
<a id='n265' href='#n265'>265</a>
<a id='n266' href='#n266'>266</a>
<a id='n267' href='#n267'>267</a>
<a id='n268' href='#n268'>268</a>
<a id='n269' href='#n269'>269</a>
<a id='n270' href='#n270'>270</a>
<a id='n271' href='#n271'>271</a>
<a id='n272' href='#n272'>272</a>
<a id='n273' href='#n273'>273</a>
<a id='n274' href='#n274'>274</a>
<a id='n275' href='#n275'>275</a>
<a id='n276' href='#n276'>276</a>
<a id='n277' href='#n277'>277</a>
<a id='n278' href='#n278'>278</a>
<a id='n279' href='#n279'>279</a>
<a id='n280' href='#n280'>280</a>
<a id='n281' href='#n281'>281</a>
<a id='n282' href='#n282'>282</a>
<a id='n283' href='#n283'>283</a>
<a id='n284' href='#n284'>284</a>
<a id='n285' href='#n285'>285</a>
<a id='n286' href='#n286'>286</a>
<a id='n287' href='#n287'>287</a>
<a id='n288' href='#n288'>288</a>
<a id='n289' href='#n289'>289</a>
<a id='n290' href='#n290'>290</a>
<a id='n291' href='#n291'>291</a>
<a id='n292' href='#n292'>292</a>
<a id='n293' href='#n293'>293</a>
<a id='n294' href='#n294'>294</a>
<a id='n295' href='#n295'>295</a>
<a id='n296' href='#n296'>296</a>
<a id='n297' href='#n297'>297</a>
<a id='n298' href='#n298'>298</a>
<a id='n299' href='#n299'>299</a>
<a id='n300' href='#n300'>300</a>
<a id='n301' href='#n301'>301</a>
<a id='n302' href='#n302'>302</a>
<a id='n303' href='#n303'>303</a>
<a id='n304' href='#n304'>304</a>
<a id='n305' href='#n305'>305</a>
<a id='n306' href='#n306'>306</a>
<a id='n307' href='#n307'>307</a>
<a id='n308' href='#n308'>308</a>
<a id='n309' href='#n309'>309</a>
<a id='n310' href='#n310'>310</a>
<a id='n311' href='#n311'>311</a>
<a id='n312' href='#n312'>312</a>
<a id='n313' href='#n313'>313</a>
<a id='n314' href='#n314'>314</a>
<a id='n315' href='#n315'>315</a>
<a id='n316' href='#n316'>316</a>
<a id='n317' href='#n317'>317</a>
<a id='n318' href='#n318'>318</a>
<a id='n319' href='#n319'>319</a>
<a id='n320' href='#n320'>320</a>
<a id='n321' href='#n321'>321</a>
<a id='n322' href='#n322'>322</a>
<a id='n323' href='#n323'>323</a>
<a id='n324' href='#n324'>324</a>
<a id='n325' href='#n325'>325</a>
<a id='n326' href='#n326'>326</a>
<a id='n327' href='#n327'>327</a>
</pre></td>
<td class='lines'><pre><code>