#include <stdio.h>
#include <assert.h>
#include <strings.h>
#include <pslib.h>

#include "pmFPA.h"
#include "pmHDU.h"
#include "pmHDUUtils.h"
#include "pmConcepts.h"
#include "pmConceptsRead.h"

//////////////////////////////////////////////////////////////////////////////////////////////////////////////
// File-static functions
//////////////////////////////////////////////////////////////////////////////////////////////////////////////

static bool compareConcepts(psMetadataItem *compare, // Item to compare
                            psMetadataItem *standard // Standard for comparison
                           )
{
    // First order checks
    if (! compare || ! standard) {
        return false;
    }
    if (strcasecmp(compare->name, standard->name) != 0) {
        return false;
    }

    // Special case: list
    if (compare->type == PS_DATA_LIST) {
        // "compare" contains a list of psMetadataItems
        // "standard" likely contains just a string (but it might possibly be a list of strings)
        psList *cList = compare->data.V; // The list from comparison item
        psList *sList = NULL;         // The list from standard item
        switch (standard->type) {
        case PS_DATA_STRING:
            sList = psStringSplit(standard->data.V, " ;", true);
            break;
        case PS_DATA_LIST:
            sList = psMemIncrRefCounter(standard->data.V);
            break;
        default:
            return false;
        }
        if (cList->n != sList->n) {
            psFree(sList);
            return false;
        }
        psVector *match = psVectorAlloc(cList->n, PS_TYPE_U8); // Array indicating which values match
        match->n = cList->n;
        psVectorInit(match, 0);
        psListIterator *cIter = psListIteratorAlloc(cList, PS_LIST_HEAD, false); // compare iterator
        psListIterator *sIter = psListIteratorAlloc(sList, PS_LIST_HEAD, false); // standard iterator
        psMetadataItem *cItem = NULL; // Item from compare list
        while ((cItem = psListGetAndIncrement(cIter))) {
            if (cItem->type != PS_DATA_STRING) {
                psLogMsg(__func__, PS_LOG_WARN, "psMetadataItem from list is of type %x instead of "
                         "%x (PS_DATA_STRING) --- can't interpret.\n", cItem->type, PS_DATA_STRING);
                psFree(cIter);
                psFree(sIter);
                psFree(match);
                psFree(sList);
                return false;
            }
            psString cString = cItem->data.V; // String from compare list
            psListIteratorSet(sIter, PS_LIST_HEAD);
            int index = 0;            // Index for list
            bool found = false;       // Found a match?
            for (psString sString = NULL; (sString = psListGetAndIncrement(sIter)) && !found; index++) {
                if (strcasecmp(cString, sString) == 0) {
                    match->data.U8[index]++;
                    found = true;
                }
            }
            if (! found) {
                // Can give up immediately
                psFree(cIter);
                psFree(sIter);
                psFree(match);
                psFree(sList);
                return false;
            }
        }
        // Make sure we got 100% matches in both directions
        bool allMatch = true;         // Did all of them match?
        for (int i = 0; i < match->n && allMatch; i++) {
            if (!match->data.U8[i]) {
                allMatch = false;
            }
        }
        psFree(cIter);
        psFree(sIter);
        psFree(sList);
        psFree(match);
        return allMatch;
    }

    return psMetadataItemCompare(compare, standard);

}


// Format a single concept
static psMetadataItem *conceptFormat(pmConceptSpec *spec, // The concept specification
                                     psMetadataItem *concept, // The concept to parse
                                     psMetadata *cameraFormat, // The camera format
                                     pmFPA *fpa, // The FPA
                                     pmChip *chip, // The chip
                                     pmCell *cell // The cell
                                    )
{
    assert(spec);
    assert(cameraFormat);

    if (concept) {
        psMetadataItem *formatted = NULL;  // The formatted concept
        if (spec->format) {
            formatted = spec->format(concept, cameraFormat, fpa, chip, cell);
        } else {
            formatted = psMemIncrRefCounter(concept);
        }

        return formatted;
    }
    return NULL;
}

// Write a single value to a header
static bool writeSingleHeader(pmHDU *hdu, // HDU for which to add to the header
                              const char *keyword, // Keyword to add
                              psMetadataItem *item // Item to add to the header
                             )
{
    assert(hdu);
    assert(keyword && strlen(keyword) > 0);
    assert(item);

    if (!hdu->header) {
        return false;
    }
    switch (item->type) {
    case PS_DATA_STRING:
        psTrace(__func__, 9, "Writing header %s: %s\n", keyword, item->data.V);
        return psMetadataAddStr(hdu->header, PS_LIST_TAIL, keyword, PS_META_REPLACE, item->comment,
                                item->data.V);
    case PS_DATA_S32:
        psTrace(__func__, 9, "Writing header %s: %d\n", keyword, item->data.S32);
        return psMetadataAddS32(hdu->header, PS_LIST_TAIL, keyword, PS_META_REPLACE, item->comment,
                                item->data.S32);
    case PS_DATA_F32:
        psTrace(__func__, 9, "Writing header %s: %f\n", keyword, item->data.F32);
        return psMetadataAddF32(hdu->header, PS_LIST_TAIL, keyword, PS_META_REPLACE, item->comment,
                                item->data.F32);
    case PS_DATA_F64:
        psTrace(__func__, 9, "Writing header %s: %f\n", keyword, item->data.F64);
        return psMetadataAddF64(hdu->header, PS_LIST_TAIL, keyword, PS_META_REPLACE, item->comment,
                                item->data.F64);
    case PS_DATA_REGION: {
            psString region = psRegionToString(*(psRegion*)item->data.V);
            psTrace(__func__, 9, "Writing header %s: %s\n", keyword, region);
            bool result = psMetadataAddStr(hdu->header, PS_LIST_TAIL, keyword, PS_META_REPLACE, item->comment,
                                           region);
            psFree(region);
            return result;
        }
    default:
        psLogMsg(__func__, PS_LOG_WARN, "Type of %s is not suitable for a FITS header --- not added.\n",
                 item->name);
        return false;
    }
}


// Write potentially multiple values to a header
static bool writeHeader(pmHDU *hdu,     // HDU for which to add to the header
                        const char *keywords, // Keywords to add
                        psMetadataItem *item // Item to add to the header
                       )
{
    assert(hdu);
    assert(keywords);
    assert(item);

    bool status = true;                 // Status of writing headers, to be returned
    if (item->type == PS_DATA_LIST) {
        psList *values = item->data.V;  // List of outputs
        if (values->n == 0) {
            // Nothing to write
            return false;
        }
        psList *keys = psStringSplit(keywords, " ,;", true); // List of keywords
        if (keys->n != values->n) {
            psLogMsg(__func__, PS_LOG_WARN, "Number of keywords (%d) does not match number of values (%d).\n",
                     keys->n, values->n);
        }
        psListIterator *keysIter = psListIteratorAlloc(keys, PS_LIST_HEAD, false); // Iterator for keywords
        psListIterator *valuesIter = psListIteratorAlloc(values, PS_LIST_HEAD, false); // Iterator for values
        psString key = NULL;            // Keyword from iteration
        psMetadataItem *value = NULL;   // Value from iteration
        while ((key = psListGetAndIncrement(keysIter)) && (value = psListGetAndIncrement(valuesIter))) {
            status |= writeSingleHeader(hdu, key, value);
        }
        psFree(keysIter);
        psFree(valuesIter);
        psFree(keys);
    } else {
        status = writeSingleHeader(hdu, keywords, item);
    }
    return status;
}


//////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Public functions
//////////////////////////////////////////////////////////////////////////////////////////////////////////////

bool pmConceptsWriteToCamera(psMetadata *specs, // The concept specifications
                             pmCell *cell,   // The cell
                             psMetadata *concepts // The concepts
                            )
{
    PS_ASSERT_PTR_NON_NULL(specs, false);
    PS_ASSERT_PTR_NON_NULL(concepts, false);
    if (!cell) {
        return false;
    }
    if (!cell->config)
        return false;

    pmHDU *hdu = pmHDUGetLowest(NULL, NULL, cell); // The HDU at the lowest level
    if (!hdu) {
        return false;
    }
    psMetadata *cameraFormat = hdu->format; // The camera format
    psMetadataIterator *specsIter = psMetadataIteratorAlloc(specs, PS_LIST_HEAD, NULL); // Iterator
    psMetadataItem *specItem = NULL;    // Item from the specs metadata
    while ((specItem = psMetadataGetAndIncrement(specsIter))) {
        pmConceptSpec *spec = specItem->data.V; // The specification
        psString name = specItem->name; // The concept name
        psMetadataItem *cameraItem = psMetadataLookup(cell->config, name); // The concept from the camera,
        // or NULL
        if (cameraItem) {
            // Grab the concept
            psMetadataItem *conceptItem = psMetadataLookup(concepts, name); // The concept
            // Formatted version
            psMetadataItem *formatted = conceptFormat(spec, conceptItem, cameraFormat, NULL, NULL, cell);
            if (!formatted) {
                continue;
            }
            psString nameSource = NULL; // String with the concept name and ".SOURCE" added
            psStringAppend(&nameSource, "%s.SOURCE", name);
            bool mdok = true;       // Status of MD lookup
            psString source = psMetadataLookupStr(&mdok, cell->config, nameSource); // The source
            if (mdok && strlen(source) > 0) {
                psTrace(__func__, 8, "%s is %s\n", nameSource, source);
                if (strcasecmp(source, "HEADER") == 0) {
                    if (cameraItem->type != PS_DATA_STRING) {
                        psLogMsg(__func__, PS_LOG_WARN, "Concept %s is specified by header, but is not "
                                 "of type STR --- ignored.\n", conceptItem->name);
                        continue;
                    }
                    psTrace(__func__, 8, "Writing %s to header %s\n", name, cameraItem->data.V);
                    writeHeader(hdu, cameraItem->data.V, formatted);
                } else if (strcasecmp(source, "VALUE") == 0) {
                    psTrace(__func__, 8, "Checking %s against camera format.\n", name);
                    if (! compareConcepts(formatted, cameraItem)) {
                        psLogMsg(__func__, PS_LOG_WARN, "Concept %s is specified by value in the camera "
                                 "format, but the values don't match.\n", name);
                    }
                } else {
                    psLogMsg(__func__, PS_LOG_WARN, "Concept source %s isn't HEADER or VALUE --- can't "
                             "write\n", nameSource);
                }
            } else if (! compareConcepts(formatted, cameraItem)) {
                // Assume it's specified by value
                psLogMsg(__func__, PS_LOG_WARN, "Concept %s is specified by value in the camera "
                         "format, but the values don't match.\n", name);
            }
            psFree(formatted);
            psFree(nameSource);
        }

    }
    psFree(specsIter);
    return true;
}

bool pmConceptsWriteToDefaults(psMetadata *specs, // The concept specifications
                               pmFPA *fpa, // The FPA
                               pmChip *chip, // The chip
                               pmCell *cell, // The cell
                               psMetadata *concepts // The concepts
                              )
{
    PS_ASSERT_PTR_NON_NULL(specs, false);
    PS_ASSERT_PTR_NON_NULL(concepts, false);

    pmHDU *hdu = pmHDUGetLowest(NULL, NULL, cell); // The HDU at the lowest level
    if (!hdu) {
        return false;
    }
    psMetadata *cameraFormat = hdu->format; // The camera format
    bool mdok = true;                   // Status of MD lookup
    psMetadata *defaults = psMetadataLookupMD(&mdok, cameraFormat, "DEFAULTS"); // The DEFAULTS spec
    if (!mdok || !defaults) {
        return false;
    }

    psMetadataIterator *specsIter = psMetadataIteratorAlloc(specs, PS_LIST_HEAD, NULL); // Iterator
    psMetadataItem *specItem = NULL;    // Item from the specs metadata
    while ((specItem = psMetadataGetAndIncrement(specsIter))) {
        pmConceptSpec *spec = specItem->data.V; // The specification
        psString name = specItem->name; // The concept name
        psMetadataItem *defaultItem = psMetadataLookup(defaults, name); // The item from the DEFAULTS
        if (defaultItem) {
            psMetadataItem *conceptItem = NULL; // The item from the concepts
            if (defaultItem->type == PS_DATA_METADATA) {
                // It's a menu --- need to look up the .DEPEND
                psString dependName = NULL; // The concept name with ".DEPEND" on the end
                psStringAppend(&dependName, ".DEPEND");
                psString dependKey = psMetadataLookupStr(&mdok, defaults, dependName); // The keyword
                psFree(dependName);
                if (!mdok || !dependKey || strlen(dependKey) == 0) {
                    psLogMsg(__func__, PS_LOG_WARN, "Can't find %s in the DEFAULTS for %s --- ignored.\n",
                             dependName, name);
                    continue;
                }
                psString dependValue = psMetadataLookupStr(&mdok, concepts, dependName); // The value
                if (!mdok || !dependKey || strlen(dependKey) == 0) {
                    psLogMsg(__func__, PS_LOG_WARN, "Concept %s specified by %s isn't of type STR -- "
                             "ignored.\n", name, dependName);
                    continue;
                }
                conceptItem = psMetadataLookup(defaultItem->data.V, dependValue);
            } else {
                conceptItem = psMetadataLookup(concepts, name); // The item from the concepts
            }
            psMetadataItem *formatted = conceptFormat(spec, conceptItem, cameraFormat, fpa, chip, cell);
            if (!formatted) {
                continue;
            }
            if (! compareConcepts(formatted, defaultItem)) {
                psLogMsg(__func__, PS_LOG_WARN, "Concept %s is specified by the DEFAULTS in the camera "
                         "format, but the values don't match.\n", name);
            }
            psFree(formatted);
        }
    }
    psFree(specsIter);
    return true;
}


bool pmConceptsWriteToHeader(psMetadata *specs, // The concept specifications
                             pmFPA *fpa, // The FPA
                             pmChip *chip, // The chip
                             pmCell *cell, // The cell
                             psMetadata *concepts // The concepts
                            )
{
    PS_ASSERT_PTR_NON_NULL(specs, false);
    PS_ASSERT_PTR_NON_NULL(concepts, false);

    pmHDU *hdu = pmHDUGetLowest(NULL, NULL, cell); // The HDU at the lowest level
    if (!hdu) {
        return false;
    }
    psMetadata *cameraFormat = hdu->format; // The camera format
    bool mdok = true;                   // Status of MD lookup
    psMetadata *translation = psMetadataLookupMD(&mdok, cameraFormat, "TRANSLATION"); // The TRANSLATION spec
    if (!mdok || !translation) {
        return false;
    }

    psMetadataIterator *specsIter = psMetadataIteratorAlloc(specs, PS_LIST_HEAD, NULL); // Iterator
    psMetadataItem *specItem = NULL;    // Item from the specs metadata
    while ((specItem = psMetadataGetAndIncrement(specsIter))) {
        pmConceptSpec *spec = specItem->data.V; // The specification
        psString name = specItem->name; // The concept name
        psMetadataItem *headerItem = psMetadataLookup(translation, name); // The item from the TRANSLATION
        if (headerItem) {
            if (headerItem->type != PS_DATA_STRING) {
                psLogMsg(__func__, PS_LOG_WARN, "TRANSLATION keyword for concept %s isn't of type STR ---"
                         " ignored.", name);
                continue;
            }
            psTrace(__func__, 3, "Writing %s to header %s\n", name, headerItem->data.V);
            psMetadataItem *conceptItem = psMetadataLookup(concepts, name); // The item from the concepts
            psMetadataItem *formatted = conceptFormat(spec, conceptItem, cameraFormat, fpa, chip, cell);
            if (!formatted) {
                continue;
            }
            psList *keywords = psStringSplit(headerItem->data.V, " ,;", true); // List of header keywords
            if (formatted->type == PS_DATA_LIST) {
                psList *values = formatted->data.V; // The values for the headers
                if (values->n != keywords->n) {
                    psLogMsg(__func__, PS_LOG_WARN, "Number of headers specified does not match number "
                             "of values for concept %s.\n", name);
                }
                psListIterator *valuesIter = psListIteratorAlloc(values, PS_LIST_HEAD, false); // Iterator
                psListIterator *keywordsIter = psListIteratorAlloc(keywords, PS_LIST_HEAD, false);
                psMetadataItem *valuesItem = NULL; // Item from list
                while ((valuesItem = psListGetAndIncrement(valuesIter))) {
                    psString keyword = psListGetAndIncrement(keywordsIter); // Keyword from the list
                    if (strlen(keyword) > 0) {
                        writeHeader(hdu, keyword, formatted);
                    }
                }
                psFree(valuesIter);
                psFree(keywordsIter);
            } else {
                psString keyword = psListGet(keywords, PS_LIST_HEAD); // The keyword
                writeHeader(hdu, keyword, formatted);
            }
            psFree(formatted);
            psFree(keywords);
        }
    }
    psFree(specsIter);
    return true;
}

// XXX Warning: This code has not been tested at all
bool pmConceptsWriteToDatabase(psMetadata *specs, // The concept specifications
                               pmFPA *fpa, // The FPA
                               pmChip *chip, // The chip
                               pmCell *cell, // The cell
                               psDB *db,// The database handle
                               psMetadata *concepts // The concepts
                              )
{
    PS_ASSERT_PTR_NON_NULL(specs, false);
    PS_ASSERT_PTR_NON_NULL(concepts, false);

    if (!db) {
        return false;
    }

    #ifdef OMIT_PSDB
    return false;
    #else

    pmHDU *hdu = pmHDUGetLowest(NULL, NULL, cell); // The HDU at the lowest level
    if (!hdu) {
        return false;
    }
    psMetadata *cameraFormat = hdu->format; // The camera format
    bool mdok = true;                   // Status of MD lookup
    psMetadata *database = psMetadataLookupMD(&mdok, cameraFormat, "DATABASE"); // The DATABASE spec
    if (!mdok || !database) {
        return false;
    }
    psMetadataIterator *specsIter = psMetadataIteratorAlloc(specs, PS_LIST_HEAD, NULL); // Iterator
    psMetadataItem *specItem = NULL;    // Item from the specs metadata
    while ((specItem = psMetadataGetAndIncrement(specsIter))) {
        pmConceptSpec *spec = specItem->data.V; // The specification
        psString name = specItem->name; // The concept name

        psMetadataItem *dbItem = psMetadataLookup(database, name); // The item from the DATABASE
        if (dbItem) {
            if (dbItem->type != PS_DATA_METADATA) {
                psLogMsg(__func__, PS_LOG_WARN, "DATABASE keyword for concept %s isn't of type METADATA "
                         "--- ignored.\n", name);
                continue;
            }

            psMetadataItem *conceptItem = psMetadataLookup(concepts, name); // The item from the concepts
            psMetadataItem *formatted = conceptFormat(spec, conceptItem, cameraFormat, fpa, chip, cell);
            if (!formatted) {
                continue;
            }

            psMetadata *dbLookup = dbItem->data.V; // How to look up the value of interest
            // Name of the table
            const char *tableName = psMetadataLookupStr(&mdok, dbLookup, "TABLE");
            // Name of "where" columns
            const char *givenCols = psMetadataLookupStr(&mdok, dbLookup, "GIVENDBCOL");
            // Values for "where" columns
            const char *givenPS = psMetadataLookupStr(&mdok, dbLookup, "GIVENPS");

            // Now, need to get the "given"s
            if (strlen(givenCols) || strlen(givenPS)) {
                psList *cols = psStringSplit(givenCols, ",;", true); // List of column names
                psList *values = psStringSplit(givenPS, ",;", true); // List of value names for the columns
                psMetadata *selection = psMetadataAlloc(); // The stuff to select in the DB
                if (cols->n != values->n) {
                    psLogMsg(__func__, PS_LOG_WARN,
                             "The GIVENDBCOL and GIVENPS entries for %s do not have "
                             "the same number of entries --- ignored.\n", name);
                } else {
                    // Iterators for the lists
                    psListIterator *colsIter = psListIteratorAlloc(cols, PS_LIST_HEAD, false);
                    psListIterator *valuesIter = psListIteratorAlloc(values, PS_LIST_HEAD, false);
                    char *column = NULL;    // Name of the column
                    while ((column = psListGetAndIncrement(colsIter))) {
                        char *dependName = psListGetAndIncrement(valuesIter); // Name for the value
                        if (!strlen(column) || !strlen(name)) {
                            psLogMsg(__func__, PS_LOG_WARN, "One of the columns or value names for %s is "
                                     " empty --- ignored.\n", name);
                        } else {
                            // Search for the value name
                            psMetadataItem *item = NULL; // The value
                            if (!item && cell) {
                                item = psMetadataLookup(cell->concepts, dependName);
                            }
                            if (!item && chip) {
                                item = psMetadataLookup(chip->concepts, dependName);
                            }
                            if (!item && fpa) {
                                item = psMetadataLookup(fpa->concepts, dependName);
                            }
                            if (! item) {
                                psLogMsg(__func__, PS_LOG_ERROR,
                                         "Unable to find the value name %s for DB "
                                         " lookup on %s --- ignored.\n", dependName, name);
                            } else {
                                // We need to create a new psMetadataItem.  I don't think we can't simply
                                // hack the existing one, since that could conceivably cause memory leaks
                                psMetadataAddItem(selection, formatted, PS_LIST_TAIL, PS_META_REPLACE);
                                psFree(formatted);
                            }
                        }
                        psFree(dependName);
                        psFree(column);
                    } // Iterating through the columns
                    psFree(colsIter);
                    psFree(valuesIter);

                    // Check first to make sure we're only going to touch one row
                    psArray *dbResult = psDBSelectRows(db, tableName, selection, 2); // Lookup result
                    // Note that we use limit=2 in order to test if there are multiple rows returned
                    if (! dbResult || dbResult->n == 0) {
                        psLogMsg(__func__, PS_LOG_WARN, "Unable to find any rows in DB for %s --- "
                                 "ignored\n", name);
                        return false;
                    } else {
                        if (dbResult->n > 1) {
                            psLogMsg(__func__, PS_LOG_WARN, "Multiple rows returned in DB lookup for %s "
                                     "--- ignored.\n", name);
                        }
                        // Update the DB
                        psMetadata *update = psMetadataAlloc();
                        psMetadataAddItem(update, conceptItem, PS_LIST_HEAD, 0);
                        psDBUpdateRows(db, tableName, selection, update);
                        psFree(update);
                        return true;
                    }
                }
                psFree(cols);
                psFree(values);
            } // Doing the "given"s.
        }
    }
    psFree(specsIter);
    return true;
    #endif
}

