/* SleepLib (DeVilbiss) Intellipap Loader Implementation
 *
 * Notes: Intellipap DV54 requires the SmartLink attachment to access this data.
 *
 * Copyright (c) 2011-2018 Mark Watkins <mark@jedimark.net>
 * Copyright (c) 2020 The OSCAR Team
 *
 * This file is subject to the terms and conditions of the GNU General Public
 * License. See the file COPYING in the main directory of the source code
 * for more details. */

#include <QDir>

#include "intellipap_loader.h"

//#define DEBUG6

ChannelID INTP_SmartFlexMode, INTP_SmartFlexLevel;

Intellipap::Intellipap(Profile *profile, MachineID id)
    : CPAP(profile, id)
{
}

Intellipap::~Intellipap()
{
}

IntellipapLoader::IntellipapLoader()
{
    const QString INTELLIPAP_ICON = ":/icons/intellipap.png";
    const QString DV6_ICON = ":/icons/dv64.png";

    QString s = newInfo().series;
    m_pixmap_paths[s] = INTELLIPAP_ICON;
    m_pixmaps[s] = QPixmap(INTELLIPAP_ICON);
    m_pixmap_paths["DV6"] = DV6_ICON;
    m_pixmaps["DV6"] = QPixmap(DV6_ICON);

    m_buffer = nullptr;
    m_type = MT_CPAP;
}

IntellipapLoader::~IntellipapLoader()
{
}

const QString SET_BIN = "SET.BIN";
const QString SET1 = "SET1";
const QString DV6 = "DV6";
const QString SL = "SL";

const QString DV6_DIR = "/" + DV6;
const QString SL_DIR = "/" + SL;

bool IntellipapLoader::Detect(const QString & givenpath)
{
    QString path = givenpath;
    if (path.endsWith(SL_DIR)) {
        path.chop(3);
    }
    if (path.endsWith(DV6_DIR)) {
        path.chop(4);
    }

    QDir dir(path);

    if (!dir.exists()) {
        return false;
    }

    // Intellipap DV54 has a folder called SL in the root directory, DV64 has DV6
    if (dir.cd(SL)) {
        // Test for presence of settings file
        return dir.exists(SET1) ? true : false;
    }

    if (dir.cd(DV6)) { // DV64
        return dir.exists(SET_BIN) ? true : false;
    }
    return false;
}

enum INTPAP_Type { INTPAP_Unknown, INTPAP_DV5, INTPAP_DV6 };


int IntellipapLoader::OpenDV5(const QString & path)
{
    QString newpath = path + SL_DIR;
    QString filename;

    qDebug() << "DV5 Loader started";

    //////////////////////////
    // Parse the Settings File
    //////////////////////////
    filename = newpath + "/" + SET1;
    QFile f(filename);

    if (!f.exists()) {
        return -1;
    }

    f.open(QFile::ReadOnly);
    QTextStream tstream(&f);

    const QString INT_PROP_Serial = "Serial";
    const QString INT_PROP_Model = "Model";
    const QString INT_PROP_Mode = "Mode";
    const QString INT_PROP_MaxPressure = "Max Pressure";
    const QString INT_PROP_MinPressure = "Min Pressure";
    const QString INT_PROP_IPAP = "IPAP";
    const QString INT_PROP_EPAP = "EPAP";
    const QString INT_PROP_PS = "PS";
    const QString INT_PROP_RampPressure = "Ramp Pressure";
    const QString INT_PROP_RampTime = "Ramp Time";

    const QString INT_PROP_HourMeter = "Usage Hours";
    const QString INT_PROP_ComplianceMeter = "Compliance Hours";
    const QString INT_PROP_ErrorCode = "Error";
    const QString INT_PROP_LastErrorCode = "Long Error";
    const QString INT_PROP_LowUseThreshold = "Low Usage";
    const QString INT_PROP_SmartFlex = "SmartFlex";
    const QString INT_PROP_SmartFlexMode = "SmartFlexMode";


    QHash<QString, QString> lookup;
        lookup["Sn"] = INT_PROP_Serial;
        lookup["Mn"] = INT_PROP_Model;
        lookup["Mo"] = INT_PROP_Mode;     // 0 cpap, 1 auto
        //lookup["Pn"]="??";
        lookup["Pu"] = INT_PROP_MaxPressure;
        lookup["Pl"] = INT_PROP_MinPressure;
        lookup["Pi"] = INT_PROP_IPAP;
        lookup["Pe"] = INT_PROP_EPAP;  // == WF on Auto models
        lookup["Ps"] = INT_PROP_PS;             // == WF on Auto models, Pressure support
        //lookup["Ds"]="??";
        //lookup["Pc"]="??";
        lookup["Pd"] = INT_PROP_RampPressure;
        lookup["Dt"] = INT_PROP_RampTime;
        //lookup["Ld"]="??";
        //lookup["Lh"]="??";
        //lookup["FC"]="??";
        //lookup["FE"]="??";
        //lookup["FL"]="??";
        lookup["A%"]="ApneaThreshold";
        lookup["Ad"]="ApneaDuration";
        lookup["H%"]="HypopneaThreshold";
        lookup["Hd"]="HypopneaDuration";
        //lookup["Pi"]="??";
        //lookup["Pe"]="??";
        lookup["Ri"]="SmartFlexIRnd";  // Inhale Rounding (0-5)
        lookup["Re"]="SmartFlexERnd"; // Inhale Rounding (0-5)
        //lookup["Bu"]="??"; // WF
        //lookup["Ie"]="??"; // 20
        //lookup["Se"]="??"; // 05    //Inspiratory trigger?
        //lookup["Si"]="??"; // 05    // Expiratory Trigger?
        //lookup["Mi"]="??"; // 0
        lookup["Uh"]="HoursMeter"; // 0000.0
        lookup["Up"]="ComplianceMeter"; // 0000.00
        //lookup["Er"]="ErrorCode";, // E00
        //lookup["El"]="LongErrorCode"; // E00 00/00/0000
        //lookup["Hp"]="??";, // 1
        //lookup["Hs"]="??";, // 02
        //lookup["Lu"]="LowUseThreshold"; // defaults to 0 (4 hours)
        lookup["Sf"] = INT_PROP_SmartFlex;
        lookup["Sm"] = INT_PROP_SmartFlexMode;
        lookup["Ks=s"]="Ks_s";
        lookup["Ks=i"]="ks_i";

    QHash<QString, QString> set1;
    QHash<QString, QString>::iterator hi;

    Machine *mach = nullptr;

    MachineInfo info = newInfo();


    bool ok;

    //EventDataType min_pressure = 0, max_pressure = 0, set_ipap = 0, set_ps = 0,
    EventDataType ramp_pressure = 0, set_epap = 0, ramp_time = 0;

    int papmode = 0, smartflex = 0, smartflexmode = 0;
    while (1) {
        QString line = tstream.readLine();

        if ((line.length() <= 2) ||
                (line.isNull())) { break; }

        QString key = line.section("\t", 0, 0).trimmed();
        hi = lookup.find(key);

        if (hi != lookup.end()) {
            key = hi.value();
        }

        QString value = line.section("\t", 1).trimmed();

        if (key == INT_PROP_Mode) {
            papmode = value.toInt(&ok);
        } else if (key == INT_PROP_Serial) {
            info.serial = value;
        } else if (key == INT_PROP_Model) {
            info.model = value;
        } else if (key == INT_PROP_MinPressure) {
            //min_pressure = value.toFloat() / 10.0;
        } else if (key == INT_PROP_MaxPressure) {
            //max_pressure = value.toFloat() / 10.0;
        } else if (key == INT_PROP_IPAP) {
            //set_ipap = value.toFloat() / 10.0;
        } else if (key == INT_PROP_EPAP) {
            set_epap = value.toFloat() / 10.0;
        } else if (key == INT_PROP_PS) {
            //set_ps = value.toFloat() / 10.0;
        } else if (key == INT_PROP_RampPressure) {
            ramp_pressure = value.toFloat() / 10.0;
        } else if (key == INT_PROP_RampTime) {
            ramp_time = value.toFloat() / 10.0;
        } else if (key == INT_PROP_SmartFlex) {
            smartflex = value.toInt();
        } else if (key == INT_PROP_SmartFlexMode) {
            smartflexmode = value.toInt();
        } else {
            set1[key] = value;
        }
        qDebug() << key << "=" << value;
    }

    CPAPMode mode = MODE_UNKNOWN;

    switch (papmode) {
    case 0:
        mode = MODE_CPAP;
        break;
    case 1:
        mode = (set_epap > 0) ? MODE_BILEVEL_FIXED : MODE_APAP;
        break;
    default:
        qDebug() << "New machine mode";
    }

    if (!info.serial.isEmpty()) {
        mach = p_profile->CreateMachine(info);
    }

    if (!mach) {
        qDebug() << "Couldn't get Intellipap machine record";
        return -1;
    }

    QString backupPath = mach->getBackupPath();
    QString copypath = path;

    if (QDir::cleanPath(path).compare(QDir::cleanPath(backupPath)) != 0) {
        copyPath(path, backupPath);
    }


    // Refresh properties data..
    for (QHash<QString, QString>::iterator i = set1.begin(); i != set1.end(); i++) {
        mach->properties[i.key()] = i.value();
    }

    f.close();

    ///////////////////////////////////////////////
    // Parse the Session Index (U File)
    ///////////////////////////////////////////////
    unsigned char buf[27];
    filename = newpath + "/U";
    f.setFileName(filename);

    if (!f.exists()) { return -1; }

    QVector<quint32> SessionStart;
    QVector<quint32> SessionEnd;
    QHash<SessionID, Session *> Sessions;

    quint32 ts1, ts2;//, length;
    //unsigned char cs;
    f.open(QFile::ReadOnly);
    int cnt = 0;
    QDateTime epoch(QDate(2002, 1, 1), QTime(0, 0, 0), Qt::UTC); // Intellipap Epoch
    int ep = epoch.toTime_t();

    do {
        cnt = f.read((char *)buf, 9);
        // big endian
        ts1 = (buf[0] << 24) | (buf[1] << 16) | (buf[2] << 8) | buf[3];
        ts2 = (buf[4] << 24) | (buf[5] << 16) | (buf[6] << 8) | buf[7];
        // buf[8] == ??? What is this byte? A Bit Field? A checksum?
        ts1 += ep;
        ts2 += ep;
        SessionStart.append(ts1);
        SessionEnd.append(ts2);
    } while (cnt > 0);

    qDebug() << "U file logs" << SessionStart.size() << "sessions.";
    f.close();

    ///////////////////////////////////////////////
    // Parse the Session Data (L File)
    ///////////////////////////////////////////////
    filename = newpath + "/L";
    f.setFileName(filename);

    if (!f.exists()) { return -1; }

    f.open(QFile::ReadOnly);
    long size = f.size();
    int recs = size / 26;
    m_buffer = new unsigned char [size];

    if (size != f.read((char *)m_buffer, size)) {
        qDebug()  << "Couldn't read 'L' data" << filename;
        return -1;
    }

    Session *sess;
    SessionID sid;
    QHash<SessionID,qint64> rampstart;
    QHash<SessionID,qint64> rampend;

    for (int i = 0; i < SessionStart.size(); i++) {
        sid = SessionStart[i];

        if (mach->SessionExists(sid)) {
            // knock out the already imported sessions..
            SessionStart[i] = 0;
            SessionEnd[i] = 0;
        } else if (!Sessions.contains(sid)) {
            sess = Sessions[sid] = new Session(mach, sid);

            sess->really_set_first(qint64(sid) * 1000L);
         //   sess->really_set_last(qint64(SessionEnd[i]) * 1000L);

            rampstart[sid] = 0;
            rampend[sid] = 0;
            sess->SetChanged(true);
            if (mode >= MODE_BILEVEL_FIXED) {
                sess->AddEventList(CPAP_IPAP, EVL_Event);
                sess->AddEventList(CPAP_EPAP, EVL_Event);
                sess->AddEventList(CPAP_PS, EVL_Event);
            } else {
                sess->AddEventList(CPAP_Pressure, EVL_Event);
            }

            sess->AddEventList(INTELLIPAP_Unknown1, EVL_Event);
            sess->AddEventList(INTELLIPAP_Unknown2, EVL_Event);

            sess->AddEventList(CPAP_LeakTotal, EVL_Event);
            sess->AddEventList(CPAP_MaxLeak, EVL_Event);
            sess->AddEventList(CPAP_TidalVolume, EVL_Event);
            sess->AddEventList(CPAP_MinuteVent, EVL_Event);
            sess->AddEventList(CPAP_RespRate, EVL_Event);
            sess->AddEventList(CPAP_Snore, EVL_Event);

            sess->AddEventList(CPAP_Obstructive, EVL_Event);
            sess->AddEventList(CPAP_VSnore, EVL_Event);
            sess->AddEventList(CPAP_Hypopnea, EVL_Event);
            sess->AddEventList(CPAP_NRI, EVL_Event);
            sess->AddEventList(CPAP_LeakFlag, EVL_Event);
            sess->AddEventList(CPAP_ExP, EVL_Event);


        } else {
            // If there is a double up, null out the earlier session
            // otherwise there will be a crash on shutdown.
            for (int z = 0; z < SessionStart.size(); z++) {
                if (SessionStart[z] == (quint32)sid) {
                    SessionStart[z] = 0;
                    SessionEnd[z] = 0;
                    break;
                }
            }

            QDateTime d = QDateTime::fromTime_t(sid);
            qDebug() << sid << "has double ups" << d;
            /*Session *sess=Sessions[sid];
            Sessions.erase(Sessions.find(sid));
            delete sess;
            SessionStart[i]=0;
            SessionEnd[i]=0; */
        }
    }

    long pos = 0;
    int rampval = 0;
    sid = 0;
    //SessionID lastsid = 0;

    //int last_minp=0, last_maxp=0, last_ps=0, last_pres = 0;

    for (int i = 0; i < recs; i++) {
        // convert timestamp to real epoch
        ts1 = ((m_buffer[pos] << 24) | (m_buffer[pos + 1] << 16) | (m_buffer[pos + 2] << 8) | m_buffer[pos + 3]) + ep;

        for (int j = 0; j < SessionStart.size(); j++) {
            sid = SessionStart[j];

            if (!sid) { continue; }

            if ((ts1 >= (quint32)sid) && (ts1 <= SessionEnd[j])) {
                Session *sess = Sessions[sid];

                qint64 time = quint64(ts1) * 1000L;
                sess->really_set_last(time);
                sess->settings[CPAP_Mode] = mode;

                int minp = m_buffer[pos + 0x13];
                int maxp = m_buffer[pos + 0x14];
                int ps = m_buffer[pos + 0x15];
                int pres = m_buffer[pos + 0xd];

                if (mode >= MODE_BILEVEL_FIXED) {
                    rampval = maxp;
                } else {
                    rampval = minp;
                }

                qint64 rs = rampstart[sid];

                if (pres < rampval) {
                    if (!rs) {
                        // ramp started


//                        int rv = pres-rampval;
//                        double ramp =

                        rampstart[sid] = time;
                    }
                    rampend[sid] = time;
                } else {
                    if (rs > 0) {
                        if (!sess->eventlist.contains(CPAP_Ramp)) {
                            sess->AddEventList(CPAP_Ramp, EVL_Event);
                        }
                        int duration = (time - rs) / 1000L;
                        sess->eventlist[CPAP_Ramp][0]->AddEvent(time, duration);

                        rampstart.remove(sid);
                        rampend.remove(sid);
                    }
                }


                // Do this after ramp, because ramp calcs might need to insert interpolated pressure samples
                if (mode >= MODE_BILEVEL_FIXED) {

                    sess->settings[CPAP_EPAP] = float(minp) / 10.0;
                    sess->settings[CPAP_IPAP] = float(maxp) / 10.0;

                    sess->settings[CPAP_PS] = float(ps) / 10.0;


                    sess->eventlist[CPAP_IPAP][0]->AddEvent(time, float(pres) / 10.0);
                    sess->eventlist[CPAP_EPAP][0]->AddEvent(time, float(pres-ps) / 10.0);
//                   rampval = maxp;

                } else {
                    sess->eventlist[CPAP_Pressure][0]->AddEvent(time, float(pres) / 10.0); // current pressure
//                    rampval = minp;

                    if (mode == MODE_APAP) {
                        sess->settings[CPAP_PressureMin] = float(minp) / 10.0;
                        sess->settings[CPAP_PressureMax] = float(maxp) / 10.0;
                    } else if (mode == MODE_CPAP) {
                        sess->settings[CPAP_Pressure] = float(maxp) / 10.0;
                    }
                }


                sess->eventlist[CPAP_LeakTotal][0]->AddEvent(time, m_buffer[pos + 0x7]); // "Average Leak"
                sess->eventlist[CPAP_MaxLeak][0]->AddEvent(time, m_buffer[pos + 0x6]); // "Max Leak"

                int rr = m_buffer[pos + 0xa];
                sess->eventlist[CPAP_RespRate][0]->AddEvent(time, rr); // Respiratory Rate
               // sess->eventlist[INTELLIPAP_Unknown1][0]->AddEvent(time, m_buffer[pos + 0xf]); //
                sess->eventlist[INTELLIPAP_Unknown1][0]->AddEvent(time, m_buffer[pos + 0xc]);

                sess->eventlist[CPAP_Snore][0]->AddEvent(time, m_buffer[pos + 0x4]); //4/5??

                if (m_buffer[pos+0x4] > 0) {
                    sess->eventlist[CPAP_VSnore][0]->AddEvent(time, m_buffer[pos + 0x5]);
                }

                // 0x0f == Leak Event
                // 0x04 == Snore?
                if (m_buffer[pos + 0xf] > 0) { // Leak Event
                    sess->eventlist[CPAP_LeakFlag][0]->AddEvent(time, m_buffer[pos + 0xf]);
                }

                if (m_buffer[pos + 0x5] > 4) { // This matches Exhale Puff.. not sure why 4
                    //MW: Are the lower 2 bits something else?

                    sess->eventlist[CPAP_ExP][0]->AddEvent(time, m_buffer[pos + 0x5]);
                }

                if (m_buffer[pos + 0x10] > 0) {
                    sess->eventlist[CPAP_Obstructive][0]->AddEvent(time, m_buffer[pos + 0x10]);
                }

                if (m_buffer[pos + 0x11] > 0) {
                    sess->eventlist[CPAP_Hypopnea][0]->AddEvent(time, m_buffer[pos + 0x11]);
                }

                if (m_buffer[pos + 0x12] > 0) { // NRI // is this == to RERA?? CA??
                    sess->eventlist[CPAP_NRI][0]->AddEvent(time, m_buffer[pos + 0x12]);
                }

                quint16 tv = (m_buffer[pos + 0x8] << 8) | m_buffer[pos + 0x9]; // correct

                sess->eventlist[CPAP_TidalVolume][0]->AddEvent(time, tv);

                EventDataType mv = tv * rr; // MinuteVent=TidalVolume * Respiratory Rate
                sess->eventlist[CPAP_MinuteVent][0]->AddEvent(time, mv / 1000.0);
                break;
            } else {
            }
            //lastsid = sid;
        }

        pos += 26;
    }

    // Close any open ramps and store the event.
    QHash<SessionID,qint64>::iterator rit;
    QHash<SessionID,qint64>::iterator rit_end = rampstart.end();

    for (rit = rampstart.begin(); rit != rit_end; ++rit) {
        qint64 rs = rit.value();
        SessionID sid = rit.key();
        if (rs > 0) {
            qint64 re = rampend[rit.key()];

            Session *sess = Sessions[sid];
            if (!sess->eventlist.contains(CPAP_Ramp)) {
                sess->AddEventList(CPAP_Ramp, EVL_Event);
            }

            int duration = (re - rs) / 1000L;
            sess->eventlist[CPAP_Ramp][0]->AddEvent(re, duration);
            rit.value() = 0;

        }
    }

    for (int i = 0; i < SessionStart.size(); i++) {
        SessionID sid = SessionStart[i];

        if (sid) {
            sess = Sessions[sid];

            if (!sess) continue;

//            quint64 first = qint64(sid) * 1000L;
            //quint64 last = qint64(SessionEnd[i]) * 1000L;

            if (sess->last() > 0) {
             //   sess->really_set_last(last);


                sess->settings[INTP_SmartFlexLevel] = smartflex;

                if (smartflexmode == 0) {
                    sess->settings[INTP_SmartFlexMode] = PM_FullTime;
                } else {
                    sess->settings[INTP_SmartFlexMode] = PM_RampOnly;
                }

                sess->settings[CPAP_RampPressure] = ramp_pressure;
                sess->settings[CPAP_RampTime] = ramp_time;

                sess->UpdateSummaries();

                addSession(sess);
            } else {
                delete sess;
            }

        }
    }

    finishAddingSessions();
    mach->Save();


    delete [] m_buffer;

    f.close();

    int c = Sessions.size();
    return c;
}

////////////////////////////////////////////////////////////////////////////
// Devilbiss DV64 Notes
// 1)  High resolution data (flow and pressure) is kept on SD for only 100 hours
// 1a) Flow graph for days without high resolution data is absent
// 1b) Pressure graph is high resolution when high res data is available and
//     only 1 per minute when using low resolution data.
// 2)  Max and Average leak rates are as reported by DV64 machine but we're
//     not sure how those measures relate to other machine's data. Leak rate
//     seems to include the intentional mask leak.
// 2a) Not sure how SmartLink calculates the pct of time of poor mask fit.
//     May be same as what we call large leak time for other machines?
////////////////////////////////////////////////////////////////////////////

struct DV6TestedModel
{
    QString model;
    QString name;
};

static const DV6TestedModel testedModels[] = {
    { "DV64D", "Blue StandardPlus" },
    { "DV64E", "Blue AutoPlus" },
    { "DV63E", "Blue (IntelliPAP 2) AutoPlus" },
    { "", "unknown product" } // List stopper -- must be last entry
};

struct DV6_S_Data // Daily summary
{
/***    
    Session * sess;
    unsigned char u1;            //00 (position)
***/    
    unsigned int start_time;     //01 Start time for date
    unsigned int stop_time;      //05 End time
    unsigned int written;        //09 timestamp when this record was written
    EventDataType hours;         //13
//    EventDataType unknown14;   //14
    EventDataType pressureAvg;   //15
    EventDataType pressureMax;   //16
    EventDataType pressure50;    //17 50th percentile
    EventDataType pressure90;    //18 90th percentile
    EventDataType pressure95;    //19 95th percentile
    EventDataType pressureStdDev;//20 std deviation
//    EventDataType unknown_21;    //21
    EventDataType leakAvg;       //22
    EventDataType leakMax;       //23
    EventDataType leak50;        //24 50th percentile
    EventDataType leak90;        //25 90th percentile
    EventDataType leak95;        //26 95th percentile
    EventDataType leakStdDev;    //27 std deviation
    EventDataType tidalVolume;   //28 & 0x29
    EventDataType avgBreathRate; //30
    EventDataType unknown_31;    //31
    EventDataType snores;        //32 snores / hypopnea per minute
    EventDataType timeInExPuf;   //33 Time in Expiratory Puff
    EventDataType timeInFL;      //34 Time in Flow Limitation
    EventDataType timeInPB;      //35 Time in Periodic Breathing
    EventDataType maskFit;       //36 mask fit (or rather, not fit) percentage
    EventDataType indexOA;       //37 Obstructive
    EventDataType indexCA;       //38 Central index
    EventDataType indexHyp;      //39 Hypopnea Index
    EventDataType unknown_40;    //40 Reserved?
    EventDataType unknown_41;    //40 Reserved?
                                 //42-48 unknown
    EventDataType pressureSetMin;   //49
    EventDataType pressureSetMax;   //50
};

#ifdef _MSC_VER
#define PACK( __Declaration__ ) __pragma( pack(push, 1) ) __Declaration__ __pragma( pack(pop) )
#else
#define PACK( __Declaration__ ) __Declaration__ __attribute__((__packed__))
#endif


// DV6_S_REC is the day structure in the S.BIN file
PACK (struct DV6_S_REC{
    unsigned char begin[4];         //0 Beginning of day
    unsigned char end[4];           //4 End of day
    unsigned char written[4];       //8 When this record was written??
    unsigned char hours;            //12 Hours in session * 10
    unsigned char unknown_13;       //13
    unsigned char pressureAvg;      //14 All pressure settings are * 10
    unsigned char pressureMax;      //15
    unsigned char pressure50;       //16 50th percentile
    unsigned char pressure90;       //17 90th percentile
    unsigned char pressure95;       //18 95th percentile
    unsigned char pressureStdDev;   //19 std deviation
    unsigned char unknown_20;       //20
    unsigned char leakAvg;          //21
    unsigned char leakMax;          //22
    unsigned char leak50;           //23 50th percentile
    unsigned char leak90;           //24 90th percentile
    unsigned char leak95;           //25 95th percentile
    unsigned char leakStdDev;       //26 std deviation
    unsigned char tv1;              //27 tidal volume = tv2 * 256 + tv1
    unsigned char tv2;              //28
    unsigned char avgBreathRate;    //29
    unsigned char unknown_30;       //30
    unsigned char snores;           //31 snores / hypopnea per minute
    unsigned char timeInExPuf;      //32 % Time in Expiratory Puff * 2
    unsigned char timeInFL;         //33 % Time in Flow Limitation * 2
    unsigned char timeInPB;         //34 % Time in Periodic Breathing * 2
    unsigned char maskFit;          //35 mask fit (or rather, not fit) percentage * 2
    unsigned char indexOA;          //36 Obstructive index * 4
    unsigned char indexCA;          //37 Central index * 4
    unsigned char indexHyp;         //38 Hypopnea Index * 4
    unsigned char unknown_39;       //39 Reserved?
    unsigned char unknown_40;       //40 Reserved?
    unsigned char unknown_41;       //41
    unsigned char unknown_42;       //42
    unsigned char unknown_43;       //43
    unsigned char unknown_44;       //44 % time snoring *4
    unsigned char unknown_45;       //45
    unsigned char unknown_46;       //46
    unsigned char unknown_47;       //47 (related to smartflex and flow rounding?)
    unsigned char pressureSetMin;   //48
    unsigned char pressureSetMax;   //49
    unsigned char unknown_50;       //50
    unsigned char unknown_51;       //51
    unsigned char unknown_52;       //52
    unsigned char unknown_53;       //53
    unsigned char checksum;         //54
});

// DV6 SET.BIN - structure of the entire file
PACK (struct SET_BIN_REC {
    char unknown_00;                        // assuming file version
    char serial[11];                        // null terminated
    unsigned char language;
    unsigned char capabilities;             // CPAP or APAP
    unsigned char unknown_11;
    unsigned char cpap_pressure;
    unsigned char unknown_12;
    unsigned char max_pressure;
    unsigned char unknown_13;
    unsigned char min_pressure;
    unsigned char alg_apnea_threshhold;     // always locked at 00
    unsigned char alg_apnea_duration;
    unsigned char alg_hypop_threshold;
    unsigned char alg_hypop_duration;
    unsigned char ramp_pressure;
    unsigned char unknown_01;
    unsigned char ramp_duration;
    unsigned char unknown_02[3];
    unsigned char smartflex_setting;
    unsigned char smartflex_when;
    unsigned char inspFlowRounding;
    unsigned char expFlowRounding;
    unsigned char complianceHours;
    unsigned char unknown_03;
    unsigned char tubing_diameter;
    unsigned char autostart_setting;
    unsigned char unknown_04;
    unsigned char show_hide;
    unsigned char unknown_05;
    unsigned char lock_flags;
    unsigned char unknown_06;
    unsigned char humidifier_setting;  // 0-5
    unsigned char unknown_7;
    unsigned char possible_alg_apnea;
    unsigned char unknown_8[7];
    unsigned char bacteria_filter;
    unsigned char unused[73];
    unsigned char checksum;
}); // http://digitalvampire.org/blog/index.php/2006/07/31/why-you-shouldnt-use-__attribute__packed/

// Unless explicitly noted, all other DV6_x_REC are definitions for the repeating data structure that follows the header
PACK (struct DV6_HEADER {
    unsigned char unknown;          // 0 always zero
    unsigned char filetype;         // 1 e.g. "R" for a R.BIN file
    unsigned char serial[11];       // 2 serial number
    unsigned char numRecords[4];    // 13 Number of records in file (always fixed, 180,000 for R.BIN)
    unsigned char recordLength;     // 17 Length of data record (always 117)
    unsigned char recordStart[4];   // 18 First record in wrap-around buffer
    unsigned char unknown_22[21];   // 22 Unknown values
    unsigned char unknown_43[8];    // 43 Seems always to be zero
    unsigned char lasttime[4];      // 51 OSCAR only: Last timestamp, in history files only
    unsigned char checksum;         // 55 Checksum
});

// DV6 E.BIN - event data
struct DV6_E_REC { // event log record
    unsigned char begin[4];
    unsigned char end[4];
    unsigned char unknown_01;
    unsigned char unknown_02;
    unsigned char unknown_03;
    unsigned char unknown_04;
    unsigned char event_type;
    unsigned char event_severity;
    unsigned char value;
    unsigned char reduction;
    unsigned char duration;
    unsigned char unknown[7];
    unsigned char checksum;
};

// DV6 U.BIN - session start and stop times
struct DV6_U_REC {
    unsigned char begin[4];
    unsigned char end[4];
    unsigned char checksum;  // possible checksum? Not really sure
};

// DV6 R.BIN - High resolution data (breath) and moderate resolution (pressure, flags)
struct DV6_R_REC {
    unsigned char timestamp[4];
    qint16 breath[50];          // 50 breath flow records at 25 Hz
    unsigned char pressure1;    // pressure in first second of frame
    unsigned char pressure2;    // pressure in second second of frame
    unsigned char unknown106;
    unsigned char unknown107;
    unsigned char flags1[4];    // flags for first second of frame
    unsigned char flags2[4];    // flags for second second of frame
    unsigned char checksum;
};

// DV6 L.BIN - Low resolution data
PACK (struct DV6_L_REC {
    unsigned char timestamp[4];     // 0 timestamp
    unsigned char maxLeak;          // 4 lpm
    unsigned char avgLeak;          // 5 lpm
    unsigned char tidalVolume6;     // 6
    unsigned char tidalVolume7;     // 7
    unsigned char breathRate;       // 8 breaths per minute
    unsigned char unknown9;         // 9
    unsigned char avgPressure;      // 10 pressure * 10
    unsigned char unknown11;        // 11 always zero?
    unsigned char unknown12;        // 12
    unsigned char pressureLimitLow; // 13 pressure * 10
    unsigned char pressureLimitHigh;// 14 pressure * 10
    unsigned char timeSnoring;      // 15
    unsigned char snoringSeverity;  // 16
    unsigned char timeEP;           // 17
    unsigned char epSeverity;       // 18
    unsigned char timeX1;           // 19 ??
    unsigned char x1Severity;       // 20 ??
    unsigned char timeX2;           // 21 ??
    unsigned char x2Severity;       // 22 ??
    unsigned char timeX3;           // 23 ??
    unsigned char x3Severity;       // 24 ??
    unsigned char apSeverity;       // 25
    unsigned char TimeApnea;        // 26
    unsigned char noaSeverity;      // 27
    unsigned char timeNOA;          // 28
    unsigned char ukSeverity;       // 29 ??
    unsigned char timeUk;           // 30 ??
    unsigned char unknown31;        // 31
    unsigned char unknown32;        // 32
    unsigned char unknown33;        // 33
    unsigned char unknownFlag34;    // 34
    unsigned char unknownTime35;    // 35
    unsigned char unknownFlag36;    // 36
    unsigned char unknown37;        // 37
    unsigned char unknown38;        // 38
    unsigned char unknown39;        // 39
    unsigned char unknown40;        // 40
    unsigned char unknown41;        // 41
    unsigned char unknown42;        // 42
    unsigned char unknown43;        // 43
    unsigned char checksum;         // 44
});

// Our structure for managing sessions
struct DV6_SessionInfo {
    Session * sess;
    DV6_S_Data *dailyData;
    SET_BIN_REC * dv6Settings;

    unsigned int begin;
    unsigned int end;
    unsigned int written;
    bool haveHighResData;
    CPAPMode mode = MODE_UNKNOWN;
};

QString card_path;
QString backup_path;
QString history_path;

MachineInfo info;
Machine * mach = nullptr;

bool rebuild_from_backups = false;
bool create_backups = false;

QMap<SessionID, DV6_S_Data> DailySummaries;
QMap<SessionID, DV6_SessionInfo> SessionData;
SET_BIN_REC * settings;

unsigned int ep = 0;

// Convert a 4-character number in DV6 data file to a standard int
unsigned int convertNum (unsigned char num[]) {
    return ((num[3] << 24) + (num[2] << 16) + (num[1] << 8) + num[0]);
}

// Convert a timestamp in DV6 data file to a standard Unix epoch timestamp as used in OSCAR
unsigned int convertTime (unsigned char time[]) {
    if (ep == 0) {
        QDateTime epoch(QDate(2002, 1, 1), QTime(0, 0, 0), Qt::UTC); // Intellipap Epoch
        ep = epoch.toTime_t();
    }
    return ((time[3] << 24) + (time[2] << 16) + (time[1] << 8) + time[0]) + ep; // Time as Unix epoch time
}

class RollingBackup
{
public:
    RollingBackup () {}
    ~RollingBackup () {
    }

    bool open (const QString filetype, DV6_HEADER * newhdr); // Open the file
    bool close();           // close the file
    bool save(QByteArray dataBA);  // save the next record in the file

private:
    DV6_HEADER hdr;       // file header
    QString filetype;
    QFile hFile;

    int record_length;      // Length of record block in incoming file
    const int maxHistFileSize = 20*10e6;   // Maximum size of file before we create a new file

    int numWritten;     // Number of records written
    quint32 lastTimestamp;
};

bool RollingBackup::open (const QString filetype, DV6_HEADER * newhdr) {
    if (!create_backups)
        return true;

    this->filetype = filetype;

    QDir hpath(history_path);
    QStringList filters;

    numWritten = 0;

    filters.append(filetype);
    filters[0].insert(1, "_*");
    hpath.setNameFilters(filters);
    hpath.setFilter(QDir::Files);
    hpath.setSorting(QDir::Name | QDir::Reversed);

    QStringList fileNames = hpath.entryList(); // Get list of files
    QFile histfile(fileNames.first());

//    bool needNewFile = false;

    // Handle first time a history file is being created
    if (fileNames.isEmpty()) {
        memcpy (&hdr, newhdr, sizeof(DV6_HEADER));
        for (int i = 0; i < 4; i++) {
            hdr.recordStart[i] = 0;
            hdr.lasttime[i] = 0;
        }
        record_length = hdr.recordLength;
    }

    // We have an existing history record
    if (! fileNames.isEmpty()) {
        // See if this file is large enough that we want to create a new file
        if (histfile.size() > maxHistFileSize) {
            memcpy (&hdr, newhdr, sizeof(DV6_HEADER));
            for (int i = 0; i < 4; i++)
                hdr.recordStart[i] = 0;

            if (!histfile.open(QIODevice::ReadOnly)) {
                qWarning() << "DV6 RollingBackup could not open" << fileNames.first() << "for reading, error code" << histfile.error() << histfile.errorString();
                return false;
            }
            record_length = hdr.recordLength;

#ifdef ROLLBACKUP
            wrap_record = convertNum(hdr.recordStart);
            if (!histfile.seek(sizeof(DV6_HEADER) + (wrap_record-1) * record_length)) {
                qWarning() << "DV6 RollingBackup unable to make initial seek to record" << wrap_record << "in" + filename << file.error() << file.errorString();
                file.close();
                return false;
            }
#endif

        }
    }

    return true;
}

bool RollingBackup::close() {
    if (!create_backups)
        return true;
    return true;
}

bool RollingBackup::save(QByteArray dataBA) {
    Q_UNUSED(dataBA)
    if (!create_backups)
        return true;
    return true;
}

class RollingFile
{
public:
    RollingFile () { }

    ~RollingFile () {
        if (data)
            delete [] data;
        data = nullptr;
        if (hdr)
            delete hdr;
        hdr = nullptr;
    }

    bool open (QString fn); // Open the file
    bool close();           // close the file
    unsigned char * get();  // read the next record in the file

    int numread () {return number_read;};   // Return number of records read
    int recnum () {return record_number;};  // Return last-read record number

    RollingBackup rb;

private:
    QString filename;
    QFile file;
    int record_length;
    int wrap_record;
    bool wrapping = false;

    int number_read = 0;    // Number of records read

    int record_number = 0;  // Number of record.  First record in the file  is #1. First record read is wrap_record;

    DV6_HEADER * hdr;       // file header

    unsigned char * data = nullptr; // record pointer
};

bool RollingFile::open(QString filetype) {

    filename = filetype;
    file.setFileName(card_path + "/" +filetype);

    if (!file.open(QIODevice::ReadOnly)) {
        qWarning() << "DV6 RollingFile could not open" << filename << "for reading, error code" << file.error() << file.errorString();
        return false;
    }

    // Save header for use in making backups of data
    hdr = new DV6_HEADER;
    QByteArray dataBA = file.read(sizeof(DV6_HEADER));
    memcpy (hdr, dataBA.data(), sizeof(DV6_HEADER));

    // Extract control information from header
    record_length = hdr->recordLength;
    wrap_record = convertNum(hdr->recordStart);
    record_number = wrap_record;
    number_read = 0;
    wrapping = false;

    // Create buffer to hold each record as it is read
    data = new unsigned char[record_length];

    // Seek to first data record in file
    if (!file.seek(sizeof(DV6_HEADER) + wrap_record * record_length)) {
        qWarning() << "DV6 RollingFile unable to make initial seek to record" << wrap_record << "in" + filename << file.error() << file.errorString();
        file.close();
        return false;
    }
#ifdef ROLLBACKUP
    if (!rb.open(filetype, hdr)) {
        qWarning() << "DV6 RollingBackup failed";
        file.close();
        return false;
    }
#endif

    qDebug() << "DV6 RollingFile opening" << filename << "at wrap record" << wrap_record;
    return true;
}

bool RollingFile::close() {
    file.close();

#ifdef ROLLBACKUP
    rb.close();
#endif

    if (data)
        delete [] data;
    data = nullptr;
    if (hdr)
        delete hdr;
    hdr = nullptr;

    return true;
}

unsigned char * RollingFile::get() {

    record_number++;

    // If we have found the wrap record again, we are done
    if (wrapping && (record_number == wrap_record))
        return nullptr;

    // Hare we reached end of file and need to wrap around to beginning?
    if (file.atEnd()) {
        if (wrapping) {
            qDebug() << "DV6 RollingFile wrap - second time through";
            return nullptr;
        }
        qDebug() << "DV6 RollingFile wrapping to beginning of data in" << filename << "record number is" << record_number-1 << "records read" << number_read;
        record_number = 0;
        wrapping = true;
        if (!file.seek(sizeof(DV6_HEADER))) {
            file.close();
            qWarning() << "DV6 RollingFile unable to seek to first data record in file";
            return nullptr;
        }
    }

    QByteArray dataBA;
    dataBA=file.read(record_length); // read next record
    if (dataBA.size() != record_length) {
        qWarning() << "DV6 RollingFile record" << record_number << "wrong length";
        file.close();
        return nullptr;
    }
#ifdef ROLLBACKUP
    if (!rb.save(dataBA)) {
        qWarning() << "DV6 RollingBackup failed";
    }
#endif

    number_read++;

//    qDebug() << "RollingFile read" << filename << "record number" << record_number << "of length" << record_length << "number read so far" << number_read;
    memcpy (data, (unsigned char *) dataBA.data(), record_length);
    return data;
}

// Returns empty QByteArray() on failure.
QByteArray fileChecksum(const QString &fileName,
                        QCryptographicHash::Algorithm hashAlgorithm)
{
    QFile f(fileName);
    if (f.open(QFile::ReadOnly)) {
        QCryptographicHash hash(hashAlgorithm);
        bool res = hash.addData(&f);
        f.close();
        if (res) {
            return hash.result();
        }
    }
    return QByteArray();
}

/***
// Return the OSCAR date that the last data was written.
// This will be considered to be the last day for which we have any data.
// Adjust to get the correct date for sessions starting after midnight.
QDate getLastDate () {
    return QDate();
}
***/

// Return date used within OSCAR, assuming day ends at split time in preferences (usually noon)
QDate getNominalDate (QDateTime dt) {
    QDate d = dt.date();
    QTime tm = dt.time();
    QTime daySplitTime = p_profile->session->getPref(STR_IS_DaySplitTime).toTime();
    if (tm < daySplitTime)
        d = d.addDays(-1);
    return d;
}
QDate getNominalDate (unsigned int dt) {
    QDateTime xdt = QDateTime::fromSecsSinceEpoch(dt);
    return getNominalDate(xdt);
}

///////////////////////////////////////////////
// U.BIN - Open and parse session list and create session data structures
//         with session start and stop times.
///////////////////////////////////////////////

bool load6Sessions () {

    RollingFile rf;
    unsigned int ts1,ts2;

    SessionData.clear();

    qDebug() << "Parsing U.BIN";

    if (!rf.open("U.BIN")) {
        qWarning() << "Unable to open U.BIN";
        return false;
    }

    do {
        DV6_U_REC * rec = (DV6_U_REC *) rf.get();
        if (rec == nullptr)
            break;
        DV6_SessionInfo sinfo;
        // big endian
        ts1 = convertTime(rec->begin); // session start time (this is also the session id)
        ts2 = convertTime(rec->end); // session end time
#ifdef DEBUG6
        qDebug() << "U.BIN Session" << QDateTime::fromTime_t(ts1).toString("MM/dd/yyyy hh:mm:ss") << ts1 << "to" << QDateTime::fromTime_t(ts2).toString("MM/dd/yyyy hh:mm:ss") << ts2;
#endif
        sinfo.sess = nullptr;
        sinfo.dailyData = nullptr;
        sinfo.begin = ts1;
        sinfo.end = ts2;
        sinfo.written = 0;
        sinfo.haveHighResData = false;

        SessionData[ts1] = sinfo;
    } while (true);

    rf.close();
    qDebug() << "DV6 U.BIN processed" << rf.numread() << "records";

    return true;
}

/////////////////////////////////////////////////////////////////////////////////
// Parse SET.BIN settings file
/////////////////////////////////////////////////////////////////////////////////

bool load6Settings (const QString & path) {

    QByteArray dataBA;

    QFile f(path+"/"+SET_BIN);

    if (f.open(QIODevice::ReadOnly)) {
        // Read and parse entire SET.BIN file
        dataBA = f.readAll();
        f.close();

        settings = (SET_BIN_REC *)dataBA.data();

    } else { // if f.open settings file
        // Settings file open failed, return
        qWarning() << "Unable to open SET.BIN file";
        return false;
    }
    return true;
}

////////////////////////////////////////////////////////////////////////////////////////
// S.BIN - Open and load day summary list
////////////////////////////////////////////////////////////////////////////////////////

bool load6DailySummaries () {
    RollingFile rf;

    DailySummaries.clear();

    if (!rf.open("S.BIN")) {
        qWarning() << "Unable to open S.BIN";
        return false;
    }

    qDebug() << "Reading S.BIN summaries";

    do {
        DV6_S_REC * rec = (DV6_S_REC *) rf.get();
        if (rec == nullptr)
            break;

        DV6_S_Data dailyData;

        dailyData.start_time = convertTime(rec->begin);
        dailyData.stop_time = convertTime(rec->end);
        dailyData.written = convertTime(rec->written);

#ifdef DEBUG6
        qDebug() << "DV6 S.BIN start" << dailyData.start_time
                 << "stop" << dailyData.stop_time
                 << "written" << dailyData.written;
#endif

        dailyData.hours = float(rec->hours) / 10.0F;
        dailyData.pressureSetMin = float(rec->pressureSetMin) / 10.0F;
        dailyData.pressureSetMax = float(rec->pressureSetMax) / 10.0F;

        // The following stuff is not necessary to decode, but can be used to verify we are on the right track
        dailyData.pressureAvg = float(rec->pressureAvg) / 10.0F;
        dailyData.pressureMax = float(rec->pressureMax) / 10.0F;
        dailyData.pressure50 = float(rec->pressure50) / 10.0F;
        dailyData.pressure90 = float(rec->pressure90) / 10.0F;
        dailyData.pressure95 = float(rec->pressure95) / 10.0F;
        dailyData.pressureStdDev = float(rec->pressureStdDev) / 10.0F;

        dailyData.leakAvg = float(rec->leakAvg) / 10.0F;
        dailyData.leakMax = float(rec->leakMax) / 10.0F;
        dailyData.leak50= float(rec->leak50) / 10.0F;
        dailyData.leak90 = float(rec->leak90) / 10.0F;
        dailyData.leak95 = float(rec->leak95) / 10.0F;
        dailyData.leakStdDev = float(rec->leakStdDev) / 10.0F;

        dailyData.tidalVolume = float(rec->tv1 | rec->tv2 << 8);
        dailyData.avgBreathRate = float(rec->avgBreathRate);

        dailyData.snores = float(rec->snores);
        dailyData.timeInExPuf = float(rec->timeInExPuf) / 2.0F;
        dailyData.timeInFL = float(rec->timeInFL) / 2.0F;
        dailyData.timeInPB = float(rec->timeInPB) / 2.0F;
        dailyData.maskFit = float(rec->maskFit) / 2.0F;
        dailyData.indexOA = float(rec->indexOA) / 4.0F;
        dailyData.indexCA = float(rec->indexCA) / 4.0F;
        dailyData.indexHyp = float(rec->indexHyp) / 4.0F;

        DailySummaries[dailyData.start_time] = dailyData;

/**** Previous loader did this:
        if (!mach->sessionlist.contains(ts1)) { // Check if already imported
            qDebug() << "Detected new Session" << ts1;
            R.sess = new Session(mach, ts1);
            R.sess->SetChanged(true);

            R.sess->really_set_first(qint64(ts1) * 1000L);
            R.sess->really_set_last(qint64(ts2) * 1000L);

            if (data[49] != data[50]) {
                R.sess->settings[CPAP_PressureMin] = R.pressureSetMin;
                R.sess->settings[CPAP_PressureMax] = R.pressureSetMax;
                R.sess->settings[CPAP_Mode] = MODE_APAP;
            } else {
                R.sess->settings[CPAP_Mode] = MODE_CPAP;
                R.sess->settings[CPAP_Pressure] = R.pressureSetMin;
            }
            R.hasMaskPressure = false;
***/

    } while (true);

    rf.close();
    qDebug() << "DV6 S.BIN processed" << rf.numread() << "records";

    return true;
}

////////////////////////////////////////////////////////////////////////////////////////
// Parse VER.BIN for model number, serial, etc.
////////////////////////////////////////////////////////////////////////////////////////

bool load6VersionInfo(const QString & path) {

    QByteArray dataBA;
    QByteArray str;

    QFile f(path+"/VER.BIN");
    info.series = "DV6";
    info.brand = "DeVilbiss";

    if (f.open(QIODevice::ReadOnly)) {
        dataBA = f.readAll();
        f.close();

        int cnt = 0;
        for (int i=0; i< dataBA.size(); ++i) { // deliberately going one further to catch end condition
            if ((dataBA.at(i) == 0) || (i >= dataBA.size()-1)) { // if null terminated or last byte

                switch(cnt) {
                case 1: // serial
                    info.serial = str;
                    break;
                case 2: // modelnumber
//                    info.model = str;
                    info.modelnumber = str;
                    info.modelnumber = info.modelnumber.trimmed();
                    for (int i = 0; i < (int)sizeof(testedModels); i++) {
                        if (   testedModels[i].model == info.modelnumber
                            || testedModels[i].model.isEmpty()) {
                            info.model = testedModels[i].name;
                            break;
                        }
                    }
                    break;
                case 7: // ??? V025RN20170
                    break;
                case 9: // ??? V014BL20150630
                    break;
                case 11: // ??? 01 09
                    break;
                case 12: // ??? 0C 0C
                    break;
                case 14: // ??? BA 0C
                    break;
                default:
                    break;

                }

                // Clear and start a new data record
                str.clear();
                cnt++;
            } else {
                // Add the character to the current string
                str.append(dataBA[i]);
            }
        }
        return true;

    } else { // if (f.open(...)
        // VER.BIN open failed
        qWarning() << "Unable to open VER.BIN";
        return false;
    }

}

////////////////////////////////////////////////////////////////////////////////////////
// Create DV6_SessionInfo structures for each session and store in SessionData qmap
////////////////////////////////////////////////////////////////////////////////////////

int create6Sessions() {
    SessionID sid = 0;
    Session * sess;
    
    for (auto sinfo=SessionData.begin(), end=SessionData.end(); sinfo != end; ++sinfo) {
        sid = sinfo->begin;

        if (mach->SessionExists(sid)) {
            // skip already imported sessions..
            qDebug() << "Session already exists" << QDateTime::fromTime_t(sid).toString("MM/dd/yyyy hh:mm:ss");

        } else if (sinfo->sess == nullptr) {
            // process new sessions
            sess = new Session(mach, sid);
#ifdef DEBUG6
            qDebug() << "Creating session" << QDateTime::fromTime_t(sinfo->begin).toString("MM/dd/yyyy hh:mm:ss") << "to" << QDateTime::fromTime_t(sinfo->end).toString("MM/dd/yyyy hh:mm:ss");
#endif

            sinfo->sess = sess;
            sinfo->dailyData = nullptr;
            sinfo->written = 0;
            sinfo->haveHighResData = false;

            sess->really_set_first(quint64(sinfo->begin) * 1000L);
            sess->really_set_last(quint64(sinfo->end) * 1000L);

//            rampstart[sid] = 0;
//            rampend[sid] = 0;
            sess->SetChanged(true);
            
            sess->AddEventList(INTELLIPAP_Unknown1, EVL_Event);
            sess->AddEventList(INTELLIPAP_Unknown2, EVL_Event);

            sess->AddEventList(CPAP_LeakTotal, EVL_Event);
            sess->AddEventList(CPAP_MaxLeak, EVL_Event);
            sess->AddEventList(CPAP_TidalVolume, EVL_Event);
            sess->AddEventList(CPAP_MinuteVent, EVL_Event);
            sess->AddEventList(CPAP_RespRate, EVL_Event);
            sess->AddEventList(CPAP_Snore, EVL_Event);

            sess->AddEventList(CPAP_Obstructive, EVL_Event);
//            sess->AddEventList(CPAP_VSnore, EVL_Event);
            sess->AddEventList(CPAP_Hypopnea, EVL_Event);
            sess->AddEventList(CPAP_NRI, EVL_Event);
//            sess->AddEventList(CPAP_LeakFlag, EVL_Event);
            sess->AddEventList(CPAP_ExP, EVL_Event);
            sess->AddEventList(CPAP_FlowLimit, EVL_Event);


        } else {
            // If there is a duplicate session, null out the earlier session
            // otherwise there will be a crash on shutdown.
//??            for (int z = 0; z < SessionStart.size(); z++) {
//??                if (SessionStart[z] == sid) {
//??                    SessionStart[z] = 0;
//??                    SessionEnd[z] = 0;
//??                    break;
//??                }
            qDebug() << sid << "has double ups" << QDateTime::fromTime_t(sid).toString("MM/dd/yyyy hh:mm:ss");
            
            /*Session *sess=Sessions[sid];
            Sessions.erase(Sessions.find(sid));
            delete sess;
            SessionStart[i]=0;
            SessionEnd[i]=0; */
        }
    }

    qDebug() << "Created" << SessionData.size() << "sessions";
    return SessionData.size();
}

////////////////////////////////////////////////////////////////////////////////////////
// Parse R.BIN for high resolution flow data
////////////////////////////////////////////////////////////////////////////////////////

bool load6HighResData () {

    RollingFile rf;
    Session *sess = nullptr;
    unsigned int rec_ts1, previousRecBegin = 0;
    bool inSession = false; // true if we are adding data to this session

    if (!rf.open("R.BIN")) {
        qWarning() << "DV6 Unable to open R.BIN";
        return false;
    }

    qDebug() << "R.BIN starting at record" << rf.recnum();

    sess = NULL;
    EventList * flow = NULL;
    EventList * pressure = NULL;
    EventList * FLG = NULL;
    EventList * snore = NULL;
//        EventList * leak = NULL;
/***
    EventList * OA  = NULL;
    EventList * HY  = NULL;
    EventList * NOA = NULL;
    EventList * EXP = NULL;
    EventList * FL  = NULL;
    EventList * PB  = NULL;
    EventList * VS  = NULL;
    EventList * LL  = NULL;
    EventList * RE  = NULL;
    bool inOA = false, inH = false, inCA = false, inExP = false, inVS = false, inFL = false, inPB = false, inRE = false, inLL = false;
    qint64 OAstart = 0, OAend = 0;
    qint64 Hstart = 0, Hend = 0;
    qint64 CAstart = 0, CAend = 0;
    qint64 ExPstart = 0, ExPend = 0;
    qint64 VSstart = 0, VSend = 0;
    qint64 FLstart = 0, FLend = 0;
    qint64 PBstart = 0, PBend = 0;
    qint64 REstart =0, REend = 0;
    qint64 LLstart =0, LLend = 0;
//    lastts1 = 0;
***/

    // sinfo is for walking through sessions when matching up with flow data records
    QMap<SessionID, DV6_SessionInfo>::iterator sinfo;
    sinfo = SessionData.begin();

    do {
        DV6_R_REC * R = (DV6_R_REC *) rf.get();
        if (R == nullptr)
            break;

        sess = sinfo->sess;

        // Get the timestamp from the record
        rec_ts1 = convertTime(R->timestamp);

        if (rec_ts1 < previousRecBegin) {
            qWarning() << "R.BIN - Corruption/Out of sequence data found, skipping record" << rf.recnum() << ", prev"
                       << QDateTime::fromTime_t(previousRecBegin).toString("MM/dd/yyyy hh:mm:ss") << previousRecBegin
                       << "this"
                       << QDateTime::fromTime_t(rec_ts1).toString("MM/dd/yyyy hh:mm:ss") << rec_ts1;
            continue;
        }

        // Look for a gap in DV6_R records.  They should be at two second intervals.
        // If there is a gap, we are probably in a new session
        if (inSession && ((rec_ts1 - previousRecBegin) > 2)) {
            if (sess) {
                sess->set_last(flow->last());
                if (sess->first() == 0)
                    qWarning() << "R.BIN first = 0 - 1320";
                EventDataType min = flow->Min();
                EventDataType max = flow->Max();
                sess->setMin(CPAP_FlowRate, min);
                sess->setMax(CPAP_FlowRate, max);
                sess->setPhysMax(CPAP_FlowRate, min); // not sure :/
                sess->setPhysMin(CPAP_FlowRate, max);
//                sess->really_set_last(flow->last());
            }
            sess = nullptr;
            flow = nullptr;
            pressure = nullptr;
            FLG = nullptr;
            snore = nullptr;
            inSession = false;
        }

        // Skip over sessions until we find one that this record is in
        while (rec_ts1 > sinfo->end) {
#ifdef DEBUG6
            qDebug() << "R.BIN - skipping session" << QDateTime::fromTime_t(sinfo->begin).toString("MM/dd/yyyy hh:mm:ss")
                     << "looking for" << QDateTime::fromTime_t(rec_ts1).toString("MM/dd/yyyy hh:mm:ss")
                     << "record" << rf.recnum();
#endif
            if (inSession && sess) {
                // update min and max
                // then add to machine
                if (sess->first() == 0)
                    qWarning() << "R.BIN first = 0 - 1284";
                EventDataType min = flow->Min();
                EventDataType max = flow->Max();
                sess->setMin(CPAP_FlowRate, min);
                sess->setMax(CPAP_FlowRate, max);
                sess->setPhysMax(CPAP_FlowRate, min); // not sure :/
                sess->setPhysMin(CPAP_FlowRate, max);

                sess = nullptr;
                flow = nullptr;
                pressure = nullptr;
                FLG = nullptr;
                snore = nullptr;
                inSession = false;
            }
            sinfo++;
            if (sinfo == SessionData.end())
                break;
        }

        previousRecBegin = rec_ts1;

        // If we have data beyond last session, we are in trouble (for unknown reasons)
        if (sinfo == SessionData.end()) {
            qWarning() << "DV6 R.BIN import ran out of sessions to match flow data, record" << rf.recnum();
            break;
        }

        // Check if record belongs in this session or a future session
        if (!inSession && rec_ts1 <= sinfo->end) {
            sess = sinfo->sess;         // this is the Session we want
            if (!inSession && sess) {
                inSession = true;
                flow = sess->AddEventList(CPAP_FlowRate, EVL_Waveform, 0.01f, 0.0f, 0.0f, 0.0f, double(2000) / double(50));
                pressure = sess->AddEventList(CPAP_Pressure, EVL_Waveform, 0.1f, 0.0f, 0.0f, 0.0f, double(2000) / double(2));
                FLG = sess->AddEventList(CPAP_FLG, EVL_Waveform, 1.0f, 0.0f, 0.0f, 0.0f, double(2000) / double(2));
                snore = sess->AddEventList(CPAP_Snore, EVL_Waveform, 1.0f, 0.0f, 0.0f, 0.0f, double(2000) / double(2));
                //                    sinfo->hasMaskPressure = true;
                //                    leak = R->sess->AddEventList(CPAP_Leak, EVL_Waveform, 1.0, 0.0, 0.0, 0.0, double(2000) / double(1));
                /***
                    OA = R->sess->AddEventList(CPAP_Obstructive, EVL_Event);
                    NOA = R->sess->AddEventList(CPAP_NRI, EVL_Event);
                    RE = R->sess->AddEventList(CPAP_RERA, EVL_Event);
                    VS = R->sess->AddEventList(CPAP_VSnore, EVL_Event);
                    HY = R->sess->AddEventList(CPAP_Hypopnea, EVL_Event);
                    EXP = R->sess->AddEventList(CPAP_ExP, EVL_Event);
                    FL = R->sess->AddEventList(CPAP_FlowLimit, EVL_Event);
                    PB = R->sess->AddEventList(CPAP_PB, EVL_Event);
                    LL = R->sess->AddEventList(CPAP_LargeLeak, EVL_Event);
***/
            }
        }
        if (inSession) {
            // Record breath and pressure waveforms
            qint64 ti = qint64(rec_ts1) * 1000;
            flow->AddWaveform(ti,R->breath,50,2000);
            pressure->AddWaveform(ti, &R->pressure1, 2, 2000);
            sinfo->haveHighResData = true;
            if (sess->first() == 0)
                qWarning() << "first = 0 - 1442";

            //////////////////////////////////////////////////////////////////
            // Show Flow Limitation Events as a graph
            //////////////////////////////////////////////////////////////////
            qint16 severity = (R->flags1[0] >> 4) & 0x03;
            FLG->AddWaveform(ti, &severity, 1, 1000);
            severity = (R->flags2[0] >> 4) & 0x03;
            FLG->AddWaveform(ti+1000, &severity, 1, 1000);

            //////////////////////////////////////////////////////////////////
            // Show Snore Events as a graph
            //////////////////////////////////////////////////////////////////
            severity = R->flags1[0] & 0x03;
            snore->AddWaveform(ti, &severity, 1, 1000);
            severity = R->flags2[0] & 0x03;
            snore->AddWaveform(ti+1000, &severity, 1, 1000);

            /****
                // Fields data[107] && data[108] are bitfields default is 0x90, occasionally 0x98

                d[0] = data[107];
                d[1] = data[108];

                //leak->AddWaveform(ti+40000, d, 2, 2000);

                // Needs to track state to pull events out cleanly..

                //////////////////////////////////////////////////////////////////
                // High Leak
                //////////////////////////////////////////////////////////////////

                if (data[110] & 3) {  // LL state 1st second
                    if (!inLL) {
                        LLstart = ti;
                        inLL = true;
                    }
                    LLend = ti+1000L;
                } else {
                    if (inLL) {
                        inLL = false;
                        LL->AddEvent(LLstart,(LLend-LLstart) / 1000L);
                        LLstart = 0;
                    }
                }
                if (data[114] & 3) {
                    if (!inLL) {
                        LLstart = ti+1000L;
                        inLL = true;
                    }
                    LLend = ti+2000L;

                } else {
                    if (inLL) {
                        inLL = false;
                        LL->AddEvent(LLstart,(LLend-LLstart) / 1000L);
                        LLstart = 0;
                    }
                }


                //////////////////////////////////////////////////////////////////
                // Obstructive Apnea
                //////////////////////////////////////////////////////////////////

                if (data[110] & 12) {  // OA state 1st second
                    if (!inOA) {
                        OAstart = ti;
                        inOA = true;
                    }
                    OAend = ti+1000L;
                } else {
                    if (inOA) {
                        inOA = false;
                        OA->AddEvent(OAstart,(OAend-OAstart) / 1000L);
                        OAstart = 0;
                    }
                }
                if (data[114] & 12) {
                    if (!inOA) {
                        OAstart = ti+1000L;
                        inOA = true;
                    }
                    OAend = ti+2000L;

                } else {
                    if (inOA) {
                        inOA = false;
                        OA->AddEvent(OAstart,(OAend-OAstart) / 1000L);
                        OAstart = 0;
                    }
                }


                //////////////////////////////////////////////////////////////////
                // Hypopnea
                //////////////////////////////////////////////////////////////////

                if (data[110] & 192) {
                    if (!inH) {
                        Hstart = ti;
                        inH = true;
                    }
                    Hend = ti + 1000L;
                } else {
                    if (inH) {
                        inH = false;
                        HY->AddEvent(Hstart,(Hend-Hstart) / 1000L);
                        Hstart = 0;
                    }
                }

                if (data[114] & 192) {
                    if (!inH) {
                        Hstart = ti+1000L;
                        inH = true;
                    }
                    Hend = ti + 2000L;
                } else {
                    if (inH) {
                        inH = false;
                        HY->AddEvent(Hstart,(Hend-Hstart) / 1000L);
                        Hstart = 0;
                    }
                }

                //////////////////////////////////////////////////////////////////
                // Non Responding Apnea Event (Are these CA's???)
                //////////////////////////////////////////////////////////////////
                if (data[110] & 48) {  // OA state 1st second
                    if (!inCA) {
                        CAstart = ti;
                        inCA = true;
                    }
                    CAend = ti+1000L;
                } else {
                    if (inCA) {
                        inCA = false;
                        NOA->AddEvent(CAstart,(CAend-CAstart) / 1000L);
                        CAstart = 0;
                    }
                }
                if (data[114] & 48) {
                    if (!inCA) {
                        CAstart = ti+1000L;
                        inCA = true;
                    }
                    CAend = ti+2000L;

                } else {
                    if (inCA) {
                        inCA = false;
                        NOA->AddEvent(CAstart,(CAend-CAstart) / 1000L);
                        CAstart = 0;
                    }
                }

                //////////////////////////////////////////////////////////////////
                // VSnore Event
                //////////////////////////////////////////////////////////////////
                if (data[109] & 3) {  // OA state 1st second
                    if (!inVS) {
                        VSstart = ti;
                        inVS = true;
                    }
                    VSend = ti+1000L;
                } else {
                    if (inVS) {
                        inVS = false;
                        VS->AddEvent(VSstart,(VSend-VSstart) / 1000L);
                        VSstart = 0;
                    }
                }
                if (data[113] & 3) {
                    if (!inVS) {
                        VSstart = ti+1000L;
                        inVS = true;
                    }
                    VSend = ti+2000L;

                } else {
                    if (inVS) {
                        inVS = false;
                        VS->AddEvent(VSstart,(VSend-VSstart) / 1000L);
                        VSstart = 0;
                    }
                }

                //////////////////////////////////////////////////////////////////
                // Expiratory puff Event
                //////////////////////////////////////////////////////////////////
                if (data[109] & 12) {  // OA state 1st second
                    if (!inExP) {
                        ExPstart = ti;
                        inExP = true;
                    }
                    ExPend = ti+1000L;
                } else {
                    if (inExP) {
                        inExP = false;
                        EXP->AddEvent(ExPstart,(ExPend-ExPstart) / 1000L);
                        ExPstart = 0;
                    }
                }
                if (data[113] & 12) {
                    if (!inExP) {
                        ExPstart = ti+1000L;
                        inExP = true;
                    }
                    ExPend = ti+2000L;

                } else {
                    if (inExP) {
                        inExP = false;
                        EXP->AddEvent(ExPstart,(ExPend-ExPstart) / 1000L);
                        ExPstart = 0;
                    }
                }

                //////////////////////////////////////////////////////////////////
                // Flow Limitation Event
                //////////////////////////////////////////////////////////////////
                if (data[109] & 48) {  // OA state 1st second
                    if (!inFL) {
                        FLstart = ti;
                        inFL = true;
                    }
                    FLend = ti+1000L;
                } else {
                    if (inFL) {
                        inFL = false;
                        FL->AddEvent(FLstart,(FLend-FLstart) / 1000L);
                        FLstart = 0;
                    }
                }
                if (data[113] & 48) {
                    if (!inFL) {
                        FLstart = ti+1000L;
                        inFL = true;
                    }
                    FLend = ti+2000L;

                } else {
                    if (inFL) {
                        inFL = false;
                        FL->AddEvent(FLstart,(FLend-FLstart) / 1000L);
                        FLstart = 0;
                    }
                }

                //////////////////////////////////////////////////////////////////
                // Periodic Breathing Event
                //////////////////////////////////////////////////////////////////
                if (data[109] & 192) {  // OA state 1st second
                    if (!inPB) {
                        PBstart = ti;
                        inPB = true;
                    }
                    PBend = ti+1000L;
                } else {
                    if (inPB) {
                        inPB = false;
                        PB->AddEvent(PBstart,(PBend-PBstart) / 1000L);
                        PBstart = 0;
                    }
                }
                if (data[113] & 192) {
                    if (!inPB) {
                        PBstart = ti+1000L;
                        inPB = true;
                    }
                    PBend = ti+2000L;

                } else {
                    if (inPB) {
                        inPB = false;
                        PB->AddEvent(PBstart,(PBend-PBstart) / 1000L);
                        PBstart = 0;
                    }
                }

                //////////////////////////////////////////////////////////////////
                // Respiratory Effort Related Arousal Event
                //////////////////////////////////////////////////////////////////
                if (data[111] & 48) {  // OA state 1st second
                    if (!inRE) {
                        REstart = ti;
                        inRE = true;
                    }
                    REend = ti+1000L;
                } else {
                    if (inRE) {
                        inRE = false;
                        RE->AddEvent(REstart,(REend-REstart) / 1000L);
                        REstart = 0;
                    }
                }
                if (data[115] & 48) {
                    if (!inRE) {
                        REstart = ti+1000L;
                        inRE = true;
                    }
                    REend = ti+2000L;

                } else {
                    if (inRE) {
                        inRE = false;
                        RE->AddEvent(REstart,(REend-REstart) / 1000L);
                        REstart = 0;
                    }
                }
***/
        }

    } while (true);

    if (inSession && sess) {
        /***
            // Close event states if they are still open, and write event.
            if (inH) HY->AddEvent(Hstart,(Hend-Hstart) / 1000L);
            if (inOA) OA->AddEvent(OAstart,(OAend-OAstart) / 1000L);
            if (inCA) NOA->AddEvent(CAstart,(CAend-CAstart) / 1000L);
            if (inLL) LL->AddEvent(LLstart,(LLend-LLstart) / 1000L);
            if (inVS) HY->AddEvent(VSstart,(VSend-VSstart) / 1000L);
            if (inExP) EXP->AddEvent(ExPstart,(ExPend-ExPstart) / 1000L);
            if (inFL) FL->AddEvent(FLstart,(FLend-FLstart) / 1000L);
            if (inPB) PB->AddEvent(PBstart,(PBend-PBstart) / 1000L);
            if (inPB) RE->AddEvent(REstart,(REend-REstart) / 1000L);
***/
        // update min and max
        // then add to machine
        if (sess->first() == 0)
            qWarning() << "R.BIN first = 0 - 1665";
        EventDataType min = flow->Min();
        EventDataType max = flow->Max();
        sess->setMin(CPAP_FlowRate, min);
        sess->setMax(CPAP_FlowRate, max);

        sess->setPhysMax(CPAP_FlowRate, min); // TODO: not sure :/
        sess->setPhysMin(CPAP_FlowRate, max);
        sess->really_set_last(flow->last());

        sess = nullptr;
        inSession = false;
    }

    rf.close();
    qDebug() << "DV6 R.BIN processed" << rf.numread() << "records";
    return true;
}

////////////////////////////////////////////////////////////////////////////////////////
// Parse L.BIN for per minute data
////////////////////////////////////////////////////////////////////////////////////////

bool load6PerMinute () {

    RollingFile rf;
    Session *sess = nullptr;
    unsigned int rec_ts1, previousRecBegin = 0;
    bool inSession = false; // true if we are adding data to this session

    if (!rf.open("L.BIN")) {
        qWarning() << "DV6 Unable to open L.BIN";
        return false;
    }

    qDebug() << "L.BIN Minute Data starting at record" << rf.recnum();

    EventList * leak = NULL;
    EventList * maxleak = NULL;
    EventList * RR  = NULL;
    EventList * Pressure  = NULL;
    EventList * TV  = NULL;
    EventList * MV = NULL;

    QMap<SessionID, DV6_SessionInfo>::iterator sinfo;
    sinfo = SessionData.begin();

    // Walk through all the records
    do {
        DV6_L_REC * rec = (DV6_L_REC *) rf.get();
        if (rec == nullptr)
            break;

        sess = sinfo->sess;

        // Get the timestamp from the record
        rec_ts1 = convertTime(rec->timestamp);

        if (rec_ts1 < previousRecBegin) {
            qWarning() << "L.BIN - Corruption/Out of sequence data found, skipping record" << rf.recnum() << ", prev"
                       << QDateTime::fromTime_t(previousRecBegin).toString("MM/dd/yyyy hh:mm:ss") << previousRecBegin
                       << "this"
                       << QDateTime::fromTime_t(rec_ts1).toString("MM/dd/yyyy hh:mm:ss") << rec_ts1;
            continue;
        }
/****
        // Look for a gap in DV6_L records.  They should be at one minute intervals.
        // If there is a gap, we are probably in a new session
        if (inSession && ((rec_ts1 - previousRecBegin) > 60)) {
            qDebug() << "L.BIN record gap, current" << QDateTime::fromTime_t(rec_ts1).toString("MM/dd/yyyy hh:mm:ss")
                     << "previous" << QDateTime::fromTime_t(previousRecBegin).toString("MM/dd/yyyy hh:mm:ss");
            sess->set_last(maxleak->last());
            sess = nullptr;
            leak = maxleak = MV = TV = RR = Pressure = nullptr;
            inSession = false;
        }
****/
        // Skip over sessions until we find one that this record is in
        while (rec_ts1 > sinfo->end) {
#ifdef DEBUG6
            qDebug() << "L.BIN - skipping session" << QDateTime::fromTime_t(sinfo->begin).toString("MM/dd/yyyy hh:mm:ss") << "looking for" << QDateTime::fromTime_t(rec_ts1).toString("MM/dd/yyyy hh:mm:ss");
#endif
            if (inSession && sess) {
                // Close the open session and update the min and max
                sess->set_last(maxleak->last());
                sess = nullptr;
                leak = maxleak = MV = TV = RR = Pressure = nullptr;
                inSession = false;
            }
            sinfo++;
            if (sinfo == SessionData.end())
                break;
        }

        previousRecBegin = rec_ts1;

        // If we have data beyond last session, we are in trouble (for unknown reasons)
        if (sinfo == SessionData.end()) {
            qWarning() << "DV6 L.BIN import ran out of sessions to match flow data";
            break;
        }

        if (rec_ts1 < previousRecBegin) {
            qWarning() << "L.BIN - Corruption/Out of sequence data found, stopping import, prev"
                       << QDateTime::fromTime_t(previousRecBegin).toString("MM/dd/yyyy hh:mm:ss")
                       << "this"
                       << QDateTime::fromTime_t(rec_ts1).toString("MM/dd/yyyy hh:mm:ss");
            break;
        }

        // Check if record belongs in this session or a future session
        if (!inSession && rec_ts1 <= sinfo->end) {
            sess = sinfo->sess;         // this is the Session we want
            if (!inSession && sess) {
                leak = sess->AddEventList(CPAP_Leak, EVL_Event); // , 1.0, 0.0, 0.0, 0.0, double(60000) / double(1));
                maxleak = sess->AddEventList(CPAP_LeakTotal, EVL_Event);// , 1.0, 0.0, 0.0, 0.0, double(60000) / double(1));
                RR = sess->AddEventList(CPAP_RespRate, EVL_Event);
                MV = sess->AddEventList(CPAP_MinuteVent, EVL_Event);
                TV = sess->AddEventList(CPAP_TidalVolume, EVL_Event);

                if (sess->last()/1000 > sinfo->end)
                    sinfo->end = sess->last()/1000;

                if (!sinfo->haveHighResData) {
                    // Don't use this pressure if we already have higher resolution data
                    Pressure = sess->AddEventList(CPAP_Pressure, EVL_Event);
                }
                if (sinfo->mode == MODE_UNKNOWN) {
                    if (rec->pressureLimitLow != rec->pressureLimitHigh) {
                        sess->settings[CPAP_PressureMin] = rec->pressureLimitLow / 10.0f;
                        sess->settings[CPAP_PressureMax] = rec->pressureLimitHigh / 10.0f;
// if available         sess->settings[CPAP_PS) = ....
                        sess->settings[CPAP_Mode] = MODE_APAP;
                        sinfo->mode = MODE_APAP;
                    } else {
                        sess->settings[CPAP_Mode] = MODE_CPAP;
                        sess->settings[CPAP_Pressure] = rec->pressureLimitHigh / 10.0f;
                        sinfo->mode = MODE_CPAP;
                    }
                    inSession = true;
                }
            }
        }
        if (inSession) {
            // Record breath and pressure waveforms
            qint64 ti = qint64(rec_ts1) * 1000;
            maxleak->AddEvent(ti, rec->maxLeak);  //???
            leak->AddEvent(ti, rec->avgLeak);     //???
            RR->AddEvent(ti, rec->breathRate);

            if (Pressure) Pressure->AddEvent(ti, rec->avgPressure / 10.0f);  // average pressure

            unsigned tv = rec->tidalVolume6 + (rec->tidalVolume7 << 8);
            MV->AddEvent(ti, rec->breathRate * tv / 1000.0 );
            TV->AddEvent(ti, tv);

            if (!sess->channelExists(CPAP_FlowRate)) {
                // No flow rate, so lets grab this data...
            }
        }

    } while (true);

    if (sess && inSession) {
        sess->set_last(maxleak->last());
    }

    rf.close();
    qDebug() << "DV6 L.BIN processed" << rf.numread() << "records";

    return true;
}

////////////////////////////////////////////////////////////////////////////////////////
// Parse E.BIN for event data
////////////////////////////////////////////////////////////////////////////////////////

bool load6EventData () {
    RollingFile rf;

    Session *sess = nullptr;
    unsigned int rec_ts1, rec_ts2, previousRecBegin;
    bool inSession = false; // true if we are adding data to this session

    EventList * OA = nullptr;
    EventList * CA = nullptr;
    EventList * H = nullptr;
    EventList * RE = nullptr;
    EventList * PB = nullptr;
    EventList * LL = nullptr;
    EventList * EP = nullptr;
    EventList * SN = nullptr;
    EventList * FL = nullptr;

    if (!rf.open("E.BIN")) {
        qWarning() << "DV6 Unable to open E.BIN";
        return false;
    }

    qDebug() << "Processing E.BIN starting at record" << rf.recnum();

    QMap<SessionID, DV6_SessionInfo>::iterator sinfo;
    sinfo = SessionData.begin();

    // Walk through all the records
    do {
        DV6_E_REC * rec = (DV6_E_REC *) rf.get();
        if (rec == nullptr)
            break;
        sess = sinfo->sess;

        // Get the timestamp from the record
        rec_ts1 = convertTime(rec->begin);
        rec_ts2 = convertTime(rec->end);

        // Skip over sessions until we find one that this record is in
        while (rec_ts1 > sinfo->end) {
#ifdef DEBUG6
            qDebug() << "E.BIN - skipping session" << QDateTime::fromTime_t(sinfo->begin).toString("MM/dd/yyyy hh:mm:ss") << "looking for" << QDateTime::fromTime_t(rec_ts1).toString("MM/dd/yyyy hh:mm:ss");
#endif
            if (inSession) {
                // Close the open session and update the min and max
                if (OA->last() > 0)
                    sess->set_last(OA->last());
                if (CA->last() > 0)
                    sess->set_last(CA->last());
                if (H->last() > 0)
                    sess->set_last(H->last());
                if (RE->last() > 0)
                    sess->set_last(RE->last());
                if (PB->last() > 0)
                    sess->set_last(PB->last());
                if (LL->last() > 0)
                    sess->set_last(LL->last());
                if (EP->last() > 0)
                    sess->set_last(EP->last());
                if (SN->last() > 0)
                    sess->set_last(SN->last());
                if (FL->last() > 0)
                    sess->set_last(FL->last());

                sess = nullptr;
                H = CA = RE = OA = PB = LL = EP = SN = FL = nullptr;
                inSession = false;
            }
            sinfo++;
            if (sinfo == SessionData.end())
                break;
        }

        previousRecBegin = rec_ts1;

        // If we have data beyond last session, we are in trouble (for unknown reasons)
        if (sinfo == SessionData.end()) {
            qWarning() << "DV6 E.BIN import ran out of sessions to match flow data";
            break;
        }

        if (rec_ts1 < previousRecBegin) {
            qWarning() << "E.BIN - Corruption/Out of sequence data found, stopping import, prev"
                       << QDateTime::fromTime_t(previousRecBegin).toString("MM/dd/yyyy hh:mm:ss")
                       << "this"
                       << QDateTime::fromTime_t(rec_ts1).toString("MM/dd/yyyy hh:mm:ss");
            break;
        }

        // Check if record belongs in this session or a future session
        if (!inSession && rec_ts1 <= sinfo->end) {
            sess = sinfo->sess;         // this is the Session we want
            if (!inSession && sess) {
                OA = sess->AddEventList(CPAP_Obstructive, EVL_Event);
                H  = sess->AddEventList(CPAP_Hypopnea, EVL_Event);
                RE = sess->AddEventList(CPAP_RERA, EVL_Event);
                CA = sess->AddEventList(CPAP_ClearAirway, EVL_Event);
                PB = sess->AddEventList(CPAP_PB, EVL_Event);
                LL = sess->AddEventList(CPAP_LargeLeak, EVL_Event);
                EP = sess->AddEventList(CPAP_ExP, EVL_Event);
//                SN = sess->AddEventList(CPAP_VSnore, EVL_Event);
                FL = sess->AddEventList(CPAP_FlowLimit, EVL_Event);

                SN = sess->AddEventList(CPAP_Snore, EVL_Waveform, 1.0f, 0.0f, 0.0f, 0.0f, double(2000) / double(2));
                inSession = true;
            }
        }
        if (inSession) {
            qint64 duration = rec_ts2 - rec_ts1;
            // We make an ad hoc adjustment to the start time so that the event lines up better with the flow graph
            // TODO: We don't know what is really going on here. Is it sloppiness on the part of the DV6 in recording time stamps?
            qint64 ti = qint64(rec_ts1 - (duration/2)) * 1000L;
            if (duration < 0) {
                qDebug() << "E.BIN at" << QDateTime::fromTime_t(rec_ts1).toString("MM/dd/yyyy hh:mm:ss")
                         << "reports duration of" << duration
                         << "ending" <<  QDateTime::fromTime_t(rec_ts2).toString("MM/dd/yyyy hh:mm:ss");
            }
            int code = rec->event_type;
            //////////////////////////////////////////////////////////////////
            // Show Snore Events as a graph
            //////////////////////////////////////////////////////////////////
            if (code == 9) {
                qint16 severity = rec->event_severity;
                SN->AddWaveform(ti, &severity, 1, duration*1000);
            }
            if (rec->event_severity >= 3)
                switch (code) {
                case 1:
                    CA->AddEvent(ti, duration);
                    break;
                case 2:
                    OA->AddEvent(ti, duration);
//                    qDebug() << "E.BIN - OA" << QDateTime::fromTime_t(rec_ts1).toString("MM/dd/yyyy hh:mm:ss") << "duration" << duration << "r" << rf.recnum();
                    break;
                case 4:
                    H->AddEvent(ti, duration);
                    break;
                case 5:
                    RE->AddEvent(ti, duration);
//                    qDebug() << "E.BIN - RERA" << QDateTime::fromTime_t(rec_ts1).toString("MM/dd/yyyy hh:mm:ss") << "duration" << duration << "r" << rf.recnum();
                    break;
                case 8:     // snore
                    SN->AddEvent(ti, duration);
//                    qDebug() << "E.BIN - Snore" << QDateTime::fromTime_t(rec_ts1).toString("MM/dd/yyyy hh:mm:ss") << "duration" << duration << "r" << rf.recnum();
                    break;
                case 9:     // expiratory puff
                    EP->AddEvent(ti, duration);
//                    qDebug() << "E.BIN - exhale puff" << QDateTime::fromTime_t(rec_ts1).toString("MM/dd/yyyy hh:mm:ss") << "duration" << duration << "r" << rf.recnum();
                    break;
                case 10:    // flow limitation
                    FL->AddEvent(ti, duration);
//                    qDebug() << "E.BIN - flow limit" << QDateTime::fromTime_t(rec_ts1).toString("MM/dd/yyyy hh:mm:ss") << "duration" << duration << "r" << rf.recnum();
                    break;
                case 11:    // periodic breathing
                    PB->AddEvent(ti, duration);
                    break;
                case 12:    // large leaks
                    LL->AddEvent(ti, duration);
//                    qDebug() << "E.BIN - large leak" << QDateTime::fromTime_t(rec_ts1).toString("MM/dd/yyyy hh:mm:ss") << "duration" << duration << "r" << rf.recnum();
                    break;
                case 13:    // pressure change
                    break;
                case 14:    // start of session
                    break;
                default:
                    break;
                }
        }
    } while (true);

    rf.close();
    qDebug() << "DV6 E.BIN processed" << rf.numread() << "records";

    return true;
}

////////////////////////////////////////////////////////////////////////////////////////
// Finalize data and add to database
////////////////////////////////////////////////////////////////////////////////////////

int addSessions() {

    for (auto si=SessionData.begin(), end=SessionData.end(); si != end; ++si) {
        Session * sess = si.value().sess;

        if (sess) {
            if ( ! mach->AddSession(sess) ) {
                qWarning() << "Session" << sess->session() << "was not addded";
            }
#ifdef DEBUG6
            else
                qDebug() << "Added session" << sess->session()  << QDateTime::fromTime_t(sess->session()).toString("MM/dd/yyyy hh:mm:ss");;
#endif

            // Update indexes, process waveform and perform flagging
            sess->UpdateSummaries();

            // Save is not threadsafe
            sess->Store(mach->getDataPath());

            // Unload them from memory
            sess->TrashEvents();
        } else
            qWarning() << "addSessions: session pointer is null";
    }

    return SessionData.size();

}

////////////////////////////////////////////////////////////////////////////////////////
// Create backup of input files
// Create dated backup of settings file if changed
////////////////////////////////////////////////////////////////////////////////////////

bool backup6 (const QString & path)  {

    if (rebuild_from_backups || !create_backups)
        return true;

    QDir ipath(path);
    QDir cpath(card_path);
    QDir bpath(backup_path);

    if ( ! bpath.exists()) {
        if ( ! bpath.mkpath(backup_path) ) {
            qWarning() << "Could not create DV6 backup directory" << backup_path;
            return false;
        }
    }

    // Copy input data to backup location
    copyPath(ipath.absolutePath(), bpath.absolutePath());

    // Create history directory for dated backups
    QDir hpath(history_path);
    if ( ! hpath.exists())
        if ( ! hpath.mkpath(history_path)) {
            qWarning() << "Could not create DV6 archive directory" << history_path;
            return false;
        }

    // Create archive of settings file if needed (SET.BIN)
    bool backup_settings = true;

    QStringList filters;

    QFile settingsFile;
    QString inputFile = cpath.absolutePath() + "/SET.BIN";
    settingsFile.setFileName(inputFile);

    filters << "SET_*.BIN";
    hpath.setNameFilters(filters);
    hpath.setFilter(QDir::Files);
    hpath.setSorting(QDir::Name | QDir::Reversed);
    QStringList fileNames = hpath.entryList(); // Get list of files
    if (! fileNames.isEmpty()) {
        QString lastFile = fileNames.first();
        qDebug() << "last settings file is" << lastFile << "new file is" << settingsFile;
        QByteArray newMD5 = fileChecksum(settingsFile.fileName(), QCryptographicHash::Md5);
        QByteArray oldMD5 = fileChecksum(hpath.absolutePath()+"/"+lastFile, QCryptographicHash::Md5);
        if (newMD5 == oldMD5)
            backup_settings = false;
    }

    if (backup_settings && !DailySummaries.isEmpty()) {
        DV6_S_Data ds = DailySummaries.last();
        QString newFile = hpath.absolutePath() + "/SET_" + getNominalDate(ds.start_time).toString("yyyyMMdd") + ".BIN";
        if (!settingsFile.copy(inputFile, newFile)) {
            qWarning() << "DV6 backup could not copy" << inputFile << "to" << newFile << ", error code" << settingsFile.error() << settingsFile.errorString();
        }
    }

    // We're done!
    return true;
}

////////////////////////////////////////////////////////////////////////////////////////
// Initialize DV6 environment
////////////////////////////////////////////////////////////////////////////////////////

bool init6Environment (const QString & path) {

    // Create Machine database record if it doesn't exist already
    mach = p_profile->CreateMachine(info);
    if (mach == nullptr) {
        qWarning() << "Could not create DV6 Machine data structure";
        return false;
    }

    backup_path = mach->getBackupPath();
    history_path = backup_path + "/HISTORY";

    // Compare QDirs rather than QStrings because separators may be different, especially on Windows.
    QDir ipath(path);
    QDir bpath(backup_path);

    if (ipath == bpath) {
        // Don't create backups if importing from backup folder
        rebuild_from_backups = true;
        create_backups = false;
    } else {
        rebuild_from_backups = false;
        create_backups = p_profile->session->backupCardData();
    }

    return true;
}

////////////////////////////////////////////////////////////////////////////////////////
// Open a DV6 SD card, parse everything, add to OSCAR database
////////////////////////////////////////////////////////////////////////////////////////

int IntellipapLoader::OpenDV6(const QString & path)
{
    qDebug() << "DV6 loader started";
    card_path = path + DV6_DIR;

    // 1. Prime the machine database's info field with this machine
    info = newInfo();

    // 2. VER.BIN - Parse model number, serial, etc. into info structure
    if (!load6VersionInfo(card_path))
        return -1;

    // 3. Initialize rest of the DV6 loader environment
    if (!init6Environment (path))
        return -1;

    // 4. SET.BIN - Parse settings file (which is only the latest settings)
    if (!load6Settings(card_path))
        return -1;

    // 5. S.BIN - Open and parse day summary list and create a list of days
    if (!load6DailySummaries())
        return -1;

    // 6. Back up data files (must do after parsing VER.BIN, S.BIN, and creating Machine)
    if (!backup6(path))
        return -1;

    // 7. U.BIN - Open and parse session list and create a list of session times
    // (S.BIN must already be loaded)
    if (!load6Sessions())
        return -1;

    // Create OSCAR session list from session times and summary data
    if (create6Sessions() <= 0)
        return -1;

    // R.BIN - Open and parse flow data
    if (!load6HighResData())
        return -1;

    // L.BIN - Open and parse per minute data
    if (!load6PerMinute())
        return -1;

    // E.BIN - Open and parse event data
    if (!load6EventData())
        return -1;

    // Finalize input
    return addSessions();
}

int IntellipapLoader::Open(const QString & dirpath)
{
    // Check for SL directory
    // Check for DV5MFirm.bin?
    QString path(dirpath);
    path = path.replace("\\", "/");

    if (path.endsWith(SL_DIR)) {
        path.chop(3);
    } else if (path.endsWith(DV6_DIR)) {
        path.chop(4);
    }

    QDir dir;

    int r = -1;
    // Sometimes there can be an SL folder because SmartLink dumps an old DV5 firmware in it, so check it first
    if (dir.exists(path + SL_DIR))
        r = OpenDV5(path);

    if ((r<0) && dir.exists(path + DV6_DIR))
        r = OpenDV6(path);

    return r;
}

void IntellipapLoader::initChannels()
{
    using namespace schema;
    Channel * chan = nullptr;
    channel.add(GRP_CPAP, chan = new Channel(INTP_SmartFlexMode = 0x1165, SETTING,  MT_CPAP,  SESSION,
        "INTPSmartFlexMode", QObject::tr("SmartFlex Mode"),
        QObject::tr("Intellipap pressure relief mode."),
        QObject::tr("SmartFlex Mode"),
        "", DEFAULT, Qt::green));


    chan->addOption(0, STR_TR_Off);
    chan->addOption(1, QObject::tr("Ramp Only"));
    chan->addOption(2, QObject::tr("Full Time"));

    channel.add(GRP_CPAP, chan = new Channel(INTP_SmartFlexLevel = 0x1169, SETTING,  MT_CPAP,  SESSION,
        "INTPSmartFlexLevel", QObject::tr("SmartFlex Level"),
        QObject::tr("Intellipap pressure relief level."),
        QObject::tr("SmartFlex Level"),
        "", DEFAULT, Qt::green));
}

bool intellipap_initialized = false;
void IntellipapLoader::Register()
{
    if (!intellipap_initialized) {
        qDebug() << "Registering IntellipapLoader";
        RegisterLoader(new IntellipapLoader());
        //InitModelMap();
        intellipap_initialized = true;
    }
    return;
}