#ifndef hSaleRunMapPaidBySaleIDTable
#define hSaleRunMapPaidBySaleIDTable


#include "PackedTable.h"

#include <map>
using namespace std;

struct _saleIDStatementItemID
{
private:
    unsigned long _sale_id;
    unsigned long _statement_item_id;

public:
    unsigned long sale_id() { return _sale_id; }
    unsigned long statement_item_id() { return _statement_item_id; }

    friend class SaleRunMapArtistPaidBySaleIDTable;
};

// We can (I think) keep the data class generic, and have specific Table classes for each run type.
// All can live in this file.
//
class SaleRunMapArtistPaidBySaleIDTable : public PackedTableDynamic
{
public:
    typedef struct _saleIDStatementItemID tData;

protected:
    enum Field { kFieldSaleID, kFieldStatementItemID };

    multimap<unsigned long, tData> _map;


    virtual const char* _maxIDQueryString() { return "SELECT MAX(sale_id) FROM sale"; }
    virtual const char* _dataQueryString() { return "SELECT sale_id,statement_item_id,status,run_type,run_id FROM sale_run_map WHERE status='paid' AND run_type='ARTR' AND run_id IN (select artist_royalty_run_id from artist_royalty_run where status in (2,5)) ORDER BY sale_id";}

    virtual long _insertRowDynamic(MYSQL_ROW row)
    {
        long saleID;
        long statementItemID;
        PackedTable::_ParseLong(row[kFieldSaleID], &saleID);
        PackedTable::_ParseLong(row[kFieldStatementItemID], &statementItemID);

        tData newData;
        newData._sale_id = saleID;
        newData._statement_item_id = statementItemID;

        _map.insert(pair<unsigned long, tData>(saleID, newData));

        return saleID;
    }


public:

    tData* nextItem() { return (tData*)_theIterator.next(); }

protected:
    // This could be big...  Let's use virtual memory rather than shared memory.
    //
    PackedTable::VirtualMemoryHandler _dataFileHandler;
//    PackedTable::SharedMemoryHandler _dataFileHandler;
    virtual DataFileHandler* _getDataFileHandler() { return &_dataFileHandler; }

    virtual unsigned long _getDynamicElementSize() { return sizeof(tData); }

    virtual unsigned long _equalKeys(void* ptrA, void* ptrB)
    {
        tData* dataA = (tData*)ptrA;
        tData* dataB = (tData*)ptrB;
        return (dataA->_sale_id == dataB->_sale_id);
    }


    multimap<unsigned long, tData>::iterator _outputIterator;

// !!! These next two methods look pretty generic - we can probably move them into the base class.
// !!! 
    virtual void* _getFirstDynamicKeyValuePtr()
    {
        _outputIterator = _map.begin();
        if (_outputIterator == _map.end())
        {
            return NULL;
        }
        return (void*) &(_outputIterator);
    }

    virtual void* _getNextDynamicKeyValuePtr()
    {
        ++_outputIterator;
        if (_outputIterator == _map.end())
        {
            return NULL;
        }
        return (void*) &(_outputIterator);
    }

    virtual long _getKey(void* dynamicDataPtr)
    {
        multimap<unsigned long, tData>::iterator *i = (multimap<unsigned long, tData>::iterator *)dynamicDataPtr;
        if (NULL == i){ return 0; }
        return (**i).first;
    }
    virtual void* _getValue(void* dynamicDataPtr)
    {
        multimap<unsigned long, tData>::iterator *i = (multimap<unsigned long, tData>::iterator *)dynamicDataPtr;
        if (NULL == i){ return 0; }
        return (void*) &((**i).second);
    }
};

#endif