/* 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 "Record_Info.h"
#include <stdint.h>
#include "zdab_utils.h"
#include "pack2b.h"
#include <stdlib.h> /* for size_t */
#include <stdio.h> /* for fprintf() */

int isOrphan(aPmtEventRecord *pmtRecord)
{
    /* Returns non-zero if the specified event is an orphan. */
    int i;

    uint32_t *mtc_data = (uint32_t *) &pmtRecord->TriggerCardData;

    for (i = 0; i < 6; ++i) {
        if (*mtc_data != 0) return 0;
        ++mtc_data;
    }

    return 1;
}

// PH 04/23/98
// Swap 4-byte integer/floats between native and external format
void swap_int32(int32_t *val_pt, int count)
{
    int32_t *last = val_pt + count;
    while (val_pt < last) {
        *val_pt = ((*val_pt << 24) & 0xff000000) |
                  ((*val_pt <<  8) & 0x00ff0000) |
                  ((*val_pt >>  8) & 0x0000ff00) |
                  ((*val_pt >> 24) & 0x000000ff);
        ++val_pt;
    }
    return;
}

// Swap 2-byte integers between native and external format
void swap_int16(int16_t *val_pt, int count)
{
    char tmp;
    int i;
    for (i=0; i<count; ++i) {
        tmp = ((char *) val_pt)[0];
        ((char *) val_pt)[0] = ((char *) val_pt)[1];
        ((char *) val_pt)[1] = tmp;
        ++val_pt;
    }
    return;
}

void unpack_mcgn(uint32_t *data, MCGNBank *b)
{
    unpack((uint8_t *) data,      "l",&b->id);
    unpack((uint8_t *) (data+1),  "l",&b->num);
    unpack((uint8_t *) (data+2),  "l",&b->radcor_proc);
    unpack((uint8_t *) (data+3),  "l",&b->radcor_made_gamma);
    unpack((uint8_t *) (data+4),  "l",&b->spare5);
    unpack((uint8_t *) (data+5),  "l",&b->spare6);
    unpack((uint8_t *) (data+7),  "l",&b->spare7);
    unpack((uint8_t *) (data+8),  "l",&b->spare8);
    unpack((uint8_t *) (data+9),  "l",&b->spare9);
    unpack((uint8_t *) (data+10), "l",&b->spare10);
    unpack((uint8_t *) (data+12), "f",&b->radcor_xtot);
    unpack((uint8_t *) (data+13), "f",&b->radcor_xdif);
    unpack((uint8_t *) (data+14), "f",&b->gentim_xpar);
    unpack((uint8_t *) (data+15), "f",&b->spare14);
    unpack((uint8_t *) (data+16), "f",&b->spare15);
    unpack((uint8_t *) (data+17), "f",&b->spare16);
    unpack((uint8_t *) (data+18), "f",&b->spare17);
    unpack((uint8_t *) (data+19), "f",&b->spare18);
    unpack((uint8_t *) (data+20), "f",&b->spare19);
    unpack((uint8_t *) (data+21), "f",&b->spare20);
}

void unpack_mcvx(uint32_t *data, MCVXBank *b)
{
    unpack((uint8_t *) data,      "l",&b->cls);
    unpack((uint8_t *) (data+1),  "l",&b->inc);
    unpack((uint8_t *) (data+2),  "f",&b->x);
    unpack((uint8_t *) (data+3),  "f",&b->y);
    unpack((uint8_t *) (data+4),  "f",&b->z);
    unpack((uint8_t *) (data+5),  "F",&b->tim);
    unpack((uint8_t *) (data+7),  "l",&b->rgn);
    unpack((uint8_t *) (data+8),  "l",&b->idm);
    unpack((uint8_t *) (data+9),  "l",&b->rg2);
    unpack((uint8_t *) (data+10), "l",&b->im2);
    unpack((uint8_t *) (data+12), "f",&b->bnx);
    unpack((uint8_t *) (data+13), "f",&b->bny);
    unpack((uint8_t *) (data+14), "f",&b->bnz);
    unpack((uint8_t *) (data+15), "l",&b->cer);
}

void unpack_mctk(uint32_t *data, MCTKBank *b)
{
    unpack((uint8_t *) data,      "l",&b->idp);
    unpack((uint8_t *) (data+1),  "f",&b->drx);
    unpack((uint8_t *) (data+2),  "f",&b->dry);
    unpack((uint8_t *) (data+3),  "f",&b->drz);
    unpack((uint8_t *) (data+4),  "f",&b->ene);
    unpack((uint8_t *) (data+5),  "l",&b->rgn);
    unpack((uint8_t *) (data+6),  "l",&b->idm);
    unpack((uint8_t *) (data+7),  "f",&b->plx);
    unpack((uint8_t *) (data+8),  "f",&b->ply);
    unpack((uint8_t *) (data+9),  "f",&b->plz);
    unpack((uint8_t *) (data+10), "f",&b->stp);
    unpack((uint8_t *) (data+11), "f",&b->near);
}

void unpack_ev(uint32_t *data, EVBank *b)
{
    unpack((uint8_t *) data,     "l",&b->run);
    unpack((uint8_t *) (data+1), "l",&b->evn);
    unpack((uint8_t *) (data+2), "l",&b->dtp);
    unpack((uint8_t *) (data+3), "l",&b->jdy);
    unpack((uint8_t *) (data+4), "l",&b->ut1);
    unpack((uint8_t *) (data+5), "l",&b->ut2);
    unpack((uint8_t *) (data+6), "l",&b->dte);
    unpack((uint8_t *) (data+7), "l",&b->hmsc);
    unpack((uint8_t *) (data+8), "l",&b->gtr1);
    unpack((uint8_t *) (data+9), "l",&b->gtr2);
    unpack((uint8_t *) (data+10),"l",&b->npm);
    unpack((uint8_t *) (data+11),"l",&b->nph);
    unpack((uint8_t *) (data+12),"l",&b->sub_run);
    unpack((uint8_t *) (data+13),"l",&b->mc_pck);
    unpack((uint8_t *) (data+14),"l",&b->rec);
    unpack((uint8_t *) (data+15),"l",&b->vpck);
    unpack((uint8_t *) (data+16),"l",&b->gtr_id);
    unpack((uint8_t *) (data+17),"l",&b->trg_type);
    unpack((uint8_t *) (data+18),"l",&b->peak);
    unpack((uint8_t *) (data+19),"l",&b->diff);
    unpack((uint8_t *) (data+20),"l",&b->integral);
    unpack((uint8_t *) (data+21),"l",&b->err);
    unpack((uint8_t *) (data+22),"l",&b->data_set);
    unpack((uint8_t *) (data+22),"lll",&b->spare1[0],
                                       &b->spare1[1],
                                       &b->spare1[2]);
    unpack((uint8_t *) (data+26),"l",&b->ncd_status);
    unpack((uint8_t *) (data+27),"l",&b->num_muxg);
    unpack((uint8_t *) (data+29),"l",&b->num_mux);
    unpack((uint8_t *) (data+29),"l",&b->num_scope);
    unpack((uint8_t *) (data+30),"lllll",&b->spare2[0],
                                         &b->spare2[1],
                                         &b->spare2[2],
                                         &b->spare2[3],
                                         &b->spare2[4]);
    unpack((uint8_t *) (data+35),"l",&b->ncd_clk_up);
    unpack((uint8_t *) (data+36),"l",&b->ncd_clk_lw);
    unpack((uint8_t *) (data+37),"l",&b->ncd_reg);
    unpack((uint8_t *) (data+38),"l",&b->ncd_gtid);
    unpack((uint8_t *) (data+39),"l",&b->ncd_sync);
    unpack((uint8_t *) (data+40),"l",&b->spare3[0],
                                     &b->spare3[1],
                                     &b->spare3[2],
                                     &b->spare3[3],
                                     &b->spare3[4],
                                     &b->spare3[5],
                                     &b->spare3[6],
                                     &b->spare3[7],
                                     &b->spare3[8],
                                     &b->spare3[9]);
}

void unpack_pmt(uint32_t *data, PMTBank *b)
{
    unpack((uint8_t *) data,"l",&b->pn);
    unpack((uint8_t *) (data+1),"l",&b->pf);
    unpack((uint8_t *) (data+2),"f",&b->pt);
    unpack((uint8_t *) (data+3),"f",&b->phl);
    unpack((uint8_t *) (data+4),"f",&b->phs);
    unpack((uint8_t *) (data+5),"f",&b->plx);
    unpack((uint8_t *) (data+6),"f",&b->pt0);
    unpack((uint8_t *) (data+7),"l",&b->pif);
    unpack((uint8_t *) (data+8),"f",&b->pit);
    unpack((uint8_t *) (data+9),"f",&b->pihl);
    unpack((uint8_t *) (data+10),"f",&b->pihs);
    unpack((uint8_t *) (data+11),"f",&b->pilx);
    unpack((uint8_t *) (data+12),"f",&b->pit0);
    unpack((uint8_t *) (data+13),"l",&b->cell);
    unpack((uint8_t *) (data+14),"l",&b->pin);
    unpack((uint8_t *) (data+15),"f",&b->tslh);
    unpack((uint8_t *) (data+16),"f",&b->hca);
    unpack((uint8_t *) (data+17),"l",&b->eca_val);
    unpack((uint8_t *) (data+18),"l",&b->pca_val);
    unpack((uint8_t *) (data+19),"l",&b->anxx);
    unpack((uint8_t *) (data+20),"f",&b->ept);
    unpack((uint8_t *) (data+21),"f",&b->ehl);
    unpack((uint8_t *) (data+22),"f",&b->ehs);
    unpack((uint8_t *) (data+23),"f",&b->elx);
    unpack((uint8_t *) (data+24),"f",&b->pt1);
    unpack((uint8_t *) (data+25),"f",&b->ptm);
    unpack((uint8_t *) (data+26),"f",&b->ptms);
    unpack((uint8_t *) (data+27),"f",&b->qm);
    unpack((uint8_t *) (data+28),"l",&b->qms);
    unpack((uint8_t *) (data+29),"f",&b->qrc);
}

int swap_PmtRecord(aPmtEventRecord *aPmtRecord, size_t size)
{
    /* Swap a Pmt Event Record. This function swaps both the Pmt event record
     * and the PMT hits and sub fields. Returns -1 if the PMT record has too
     * many hits. */
    SWAP_INT32(aPmtRecord, sizeof(aPmtEventRecord)/sizeof(uint32_t));

    int npmt = aPmtRecord->NPmtHit;

    if (npmt > MAX_NHIT) {
        fprintf(stderr, "Read error: Bad ZDAB -- %d pmt hit!", npmt);
        return -1;
    } else {
        if (size < sizeof(aPmtEventRecord) + 3*npmt*4) {
            fprintf(stderr, "swap_PmtRecord: size of record is %zu bytes, but there are %i PMT hits", size, npmt);
            return -1;
        }
        // swap the hit data
        SWAP_INT32(aPmtRecord + 1, 3*npmt);
        // swap the sub-fields
        uint32_t *sub_header = &aPmtRecord->CalPckType;
        while (*sub_header & SUB_NOT_LAST) {
            if (size < (sub_header - (uint32_t *) aPmtRecord)*4 + (*sub_header & SUB_LENGTH_MASK)*4 + 4) {
                fprintf(stderr, "swap_PmtRecord: size of record is %zu bytes, "
                    "but sub-field requires %lu bytes",
                    size,
                    (sub_header - (uint32_t *) aPmtRecord)*4 + (*sub_header & SUB_LENGTH_MASK)*4 + 4);
                return -1;
            }
            sub_header += (*sub_header & SUB_LENGTH_MASK);
            SWAP_INT32(sub_header, 1); // swap the sub-field header
            // get number of data words (-1 because we don't want to include header size)
            uint32_t data_words = (*sub_header & SUB_LENGTH_MASK) - 1;
            if (size < (sub_header - (uint32_t *) aPmtRecord)*4 + (*sub_header & SUB_LENGTH_MASK)*4) {
                fprintf(stderr, "swap_PmtRecord: size of record is %zu bytes, "
                    "but sub-field requires %lu bytes",
                    size,
                    (sub_header - (uint32_t *) aPmtRecord)*4 + (*sub_header & SUB_LENGTH_MASK)*4);
                return -1;
            }
            SWAP_INT32(sub_header+1, data_words);
        }
    }

    return 0;
}

void swap_TrigRecord(struct TriggerInfo *aTrigRecord)
{
    /* Byte swap a Trigger Record. */
    SWAP_INT32(aTrigRecord, sizeof(struct TriggerInfo)/sizeof(uint32_t));
}

void swap_RunRecord(struct RunRecord *aRunRecord)
{
    /* Byte swap a Run Record. */
    SWAP_INT32(aRunRecord, sizeof(struct RunRecord)/sizeof(uint32_t));
}