/*
 * palm-db-tools: Read/write DB-format databases
 * Copyright (C) 1999-2001 by Tom Dyas (tdyas@users.sourceforge.net)
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifh Floor, Boston, MA  02110-1301  USA
 */

#include <iostream>
#include <vector>
#include <string>
#include <stdexcept>
#include <sstream>
#include <time.h>

#include <cstring>

#include <kdebug.h>

#include "../strop.h"

#include "DB.h"

#include <kdebug.h>

#define charSeperator '/'
#define VIEWFLAG_USE_IN_EDITVIEW 0x01

#define INVALID_DEFAULT 0
#define NOW_DEFAULT 1
#define CONSTANT_DEFAULT 2

using namespace PalmLib::FlatFile;
using namespace PalmLib;

namespace {
  static const pi_uint16_t CHUNK_FIELD_NAMES         = 0;
  static const pi_uint16_t CHUNK_FIELD_TYPES         = 1;
  static const pi_uint16_t CHUNK_FIELD_DATA          = 2;
  static const pi_uint16_t CHUNK_LISTVIEW_DEFINITION = 64;
  static const pi_uint16_t CHUNK_LISTVIEW_OPTIONS    = 65;
  static const pi_uint16_t CHUNK_LFIND_OPTIONS       = 128;
  static const pi_uint16_t CHUNK_ABOUT               = 254;
}

template <class Map, class Key>
static inline bool has_key(const Map& map, const Key& key)
{
    return map.find(key) != map.end();
}

bool PalmLib::FlatFile::DB::classify(PalmLib::Database& pdb)
{
    return (! pdb.isResourceDB())
        && (pdb.creator() == PalmLib::mktag('D','B','O','S'))
        && (pdb.type()    == PalmLib::mktag('D','B','0','0'));
}

bool PalmLib::FlatFile::DB::match_name(const std::string& name)
{
    return (name == "DB") || (name == "db");
}

void PalmLib::FlatFile::DB::extract_chunks(const PalmLib::Block& appinfo)
{
    size_t i;
    pi_uint16_t chunk_type;
    pi_uint16_t chunk_size;

    if (appinfo.size() > 4) {
        // Loop through each chunk in the block while data remains.
        i = 4;
        while (i < appinfo.size()) {
            /* Stop the loop if there is not enough room for even one
             * chunk header.
             */
            if (i + 4 >= appinfo.size()) {
//                throw PalmLib::error("header is corrupt");
                 kdDebug() << "header is corrupt" << endl;
            }
            // Copy the chunk type and size into the local buffer.
            chunk_type = get_short(appinfo.data() + i);
            chunk_size = get_short(appinfo.data() + i + 2);
            i += 4;

            // Copy the chunk into seperate storage.
            Chunk chunk(appinfo.data() + i, chunk_size);
            chunk.chunk_type = chunk_type;
            m_chunks[chunk.chunk_type].push_back(chunk);

            /* Advance the index by the size of the chunk. */
            i += chunk.size();
        }

        // If everything was correct, then we should be exactly at the
        // end of the block.
        if (i != appinfo.size()) {
//            throw PalmLib::error("header is corrupt");
            kdDebug() << "header is corrupt" << endl;
        }
    } else {
//        throw PalmLib::error("header is corrupt");
        kdDebug() << "header is corrupt" << endl;
    }
}

void PalmLib::FlatFile::DB::extract_schema(unsigned numFields)
{
    unsigned i;

    if (!has_key(m_chunks, CHUNK_FIELD_NAMES)
        || !has_key(m_chunks, CHUNK_FIELD_TYPES)) {
//        throw PalmLib::error("database is missing its schema");
        kdDebug() << "database is missing its schema" << endl;
        return;
    }

    Chunk names_chunk = m_chunks[CHUNK_FIELD_NAMES][0];
    Chunk types_chunk = m_chunks[CHUNK_FIELD_TYPES][0];
    pi_char_t* p = names_chunk.data();
    pi_char_t* q = types_chunk.data();

    // Ensure that the types chunk has the expected size.
    if (types_chunk.size() != numFields * sizeof(pi_uint16_t)) {
//        throw PalmLib::error("types chunk is corrupt");
        kdDebug() << "types chunk is corrupt" << endl;
    }
    // Loop for each field and extract the name and type.
    for (i = 0; i < numFields; ++i) {
        PalmLib::FlatFile::Field::FieldType type;
        int len;

        // Determine the length of the name string. Ensure that the
        // string does not go beyond the end of the chunk.
        pi_char_t* null_p = reinterpret_cast<pi_char_t*>
            (memchr(p, 0, names_chunk.size() - (p - names_chunk.data())));
        if (!null_p) {
//            throw PalmLib::error("names chunk is corrupt");
            kdDebug() << "names chunk is corrupt" << endl;
        }
        len = null_p - p;

        switch (PalmLib::get_short(q)) {
        case 0:
            type = PalmLib::FlatFile::Field::STRING;
            break;

        case 1:
            type = PalmLib::FlatFile::Field::BOOLEAN;
            break;

        case 2:
            type = PalmLib::FlatFile::Field::INTEGER;
            break;

        case 3:
            type = PalmLib::FlatFile::Field::DATE;
            break;

        case 4:
            type = PalmLib::FlatFile::Field::TIME;
            break;

        case 5:
            type = PalmLib::FlatFile::Field::NOTE;
            break;

        case 6:
            type = PalmLib::FlatFile::Field::LIST;
            break;

        case 7:
            type = PalmLib::FlatFile::Field::LINK;
            break;

        case 8:
            type = PalmLib::FlatFile::Field::FLOAT;
            break;

        case 9:
            type = PalmLib::FlatFile::Field::CALCULATED;
            break;

        case 10:
            type = PalmLib::FlatFile::Field::LINKED;
            break;

        default:
//            throw PalmLib::error("unknown field type");
            kdDebug() << "PalmLib::FlatFile::DB::extract_schema() - unknown field type" <<  endl;
            type = PalmLib::FlatFile::Field::STRING;
            break;
        }

        // Inform the superclass about this field.
        appendField(std::string((char *) p, len), type, extract_fieldsdata(i, type));

        // Advance to the information on the next field.
        p += len + 1;
        q += 2;
    }
}

void PalmLib::FlatFile::DB::extract_listviews()
{
    if (!has_key(m_chunks, CHUNK_LISTVIEW_DEFINITION))
        return;

/*        throw PalmLib::error("no list views in database");*/

    const std::vector<Chunk>& chunks = m_chunks[CHUNK_LISTVIEW_DEFINITION];

    for (std::vector<Chunk>::const_iterator iter = chunks.begin();
         iter != chunks.end(); ++iter) {
        const Chunk& chunk = (*iter);
        PalmLib::FlatFile::ListView lv;

        if (chunk.size() < (2 + 2 + 32)) {
//            throw PalmLib::error("list view is corrupt");
            kdDebug() << "list view is corrupt" << endl;
        }
        pi_uint16_t flags = PalmLib::get_short(chunk.data());
        pi_uint16_t num_cols = PalmLib::get_short(chunk.data() + 2);

        lv.editoruse = false;
        if (flags & VIEWFLAG_USE_IN_EDITVIEW)
          lv.editoruse = true;

        if (chunk.size() != static_cast<unsigned> (2 + 2 + 32 + num_cols * 4)) {
//           throw PalmLib::error("list view is corrupt");
           kdDebug() << "list view is corrupt" << endl;
        }
        // Determine the length of the name string.
        pi_char_t* null_ptr = const_cast<pi_char_t*>(reinterpret_cast<const pi_char_t*>
            (memchr(chunk.data() + 4, 0, 32)));
        if (null_ptr)
            lv.name = std::string((char *) (chunk.data() + 4),
                                  null_ptr - (chunk.data() + 4));
        else
            lv.name = "Unknown";

        const pi_char_t* p = chunk.data() + 2 + 2 + 32;
        for (int i = 0; i < num_cols; ++i) {
            pi_uint16_t field = PalmLib::get_short(p);
            pi_uint16_t width = PalmLib::get_short(p + 2);
            p += 2 * sizeof(pi_uint16_t);

            if (field >= getNumOfFields()) {
//                throw PalmLib::error("list view is corrupt");
                kdDebug() << "list view is corrupt" << endl;
            }
            PalmLib::FlatFile::ListViewColumn col(field, width);
            lv.push_back(col);
        }

        appendListView(lv);
    }
}

std::string PalmLib::FlatFile::DB::extract_fieldsdata(pi_uint16_t field_search, PalmLib::FlatFile::Field::FieldType type)
{
    std::ostringstream theReturn;

    if (!has_key(m_chunks, CHUNK_FIELD_DATA))
        return std::string(theReturn.str());

    std::vector<Chunk>& chunks = m_chunks[CHUNK_FIELD_DATA];

    pi_uint16_t field_num = 0;
    bool find = false;
    std::vector<Chunk>::const_iterator iter = chunks.begin();
    for ( ; iter != chunks.end(); ++iter) {
        const Chunk& chunk = (*iter);

            field_num = PalmLib::get_short(chunk.data());

        if (field_num == field_search) {
            find = true;
            break;
        }
    }

    if (find) {
        const Chunk& chunk = (*iter);

        switch (type) {

            case PalmLib::FlatFile::Field::STRING:
            theReturn << std::string((const char *)chunk.data()+2, chunk.size() - 2);
        break;

        case PalmLib::FlatFile::Field::BOOLEAN:
        break;

        case PalmLib::FlatFile::Field::INTEGER:
            theReturn << PalmLib::get_long(chunk.data() + sizeof(pi_uint16_t));
            theReturn << charSeperator;
            theReturn << PalmLib::get_short(chunk.data() + sizeof(pi_uint16_t) + sizeof(pi_uint32_t));
        break;

        case PalmLib::FlatFile::Field::FLOAT: {
            pi_double_t value;
            value.words.hi = PalmLib::get_long(chunk.data() + 2);
            value.words.lo = PalmLib::get_long(chunk.data() + 6);

            theReturn << value.number;
        }
        break;

        case PalmLib::FlatFile::Field::DATE:
            if (*(chunk.data() + sizeof(pi_uint16_t)) == NOW_DEFAULT)
                theReturn << "now";
            else if (*(chunk.data() + sizeof(pi_uint16_t)) == CONSTANT_DEFAULT) {
                const pi_char_t * ptr = chunk.data() + sizeof(pi_uint16_t) + 1;
                struct tm date;
                            date.tm_year = PalmLib::get_short(ptr) - 1900;
                            date.tm_mon = (static_cast<int> (*(ptr + 2))) - 1;
                            date.tm_mday = static_cast<int> (*(ptr + 3));

                        (void) mktime(&date);

                        char buf[1024];

                        // Clear out the output buffer.
                        memset(buf, 0, sizeof(buf));

                        // Convert and output the date using the format.
                        strftime(buf, sizeof(buf), "%Y/%m/%d", &date);

                theReturn << buf;
            }
        break;

        case PalmLib::FlatFile::Field::TIME:
            if (*(chunk.data() + sizeof(pi_uint16_t)) == NOW_DEFAULT)
                theReturn << "now";
            else if (*(chunk.data() + sizeof(pi_uint16_t)) == CONSTANT_DEFAULT) {
                const pi_char_t * ptr = chunk.data() + sizeof(pi_uint16_t) + 1;
                struct tm t;
                const struct tm * tm_ptr;
                time_t now;

                time(&now);
                tm_ptr = localtime(&now);
                memcpy(&t, tm_ptr, sizeof(tm));

                t.tm_hour = static_cast<int> (*(ptr));
                t.tm_min = static_cast<int> (*(ptr + 1));
                t.tm_sec = 0;

                char buf[1024];

                // Clear out the output buffer.
                memset(buf, 0, sizeof(buf));

                // Convert and output the date using the format.
                strftime(buf, sizeof(buf), "%H:%M", &t);

                theReturn << buf;
            }
        break;

        case PalmLib::FlatFile::Field::NOTE:
        break;

        case PalmLib::FlatFile::Field::LIST: {
            unsigned short numItems = PalmLib::get_short(chunk.data() + sizeof(pi_uint16_t));
            int prevLength = 0;
            std::string item;

            if (numItems > 0) {
                for (unsigned short i = 0; i < numItems - 1; i++) {
                    item = std::string((const char *)chunk.data() + 3 * sizeof(pi_uint16_t) + prevLength);
                    theReturn << item << charSeperator;
                    prevLength += item.length() + 1;
                }
                item = std::string((const char *)chunk.data() + 3 * sizeof(pi_uint16_t) + prevLength);
                theReturn << item;
            }
        }
        break;

        case PalmLib::FlatFile::Field::LINK:
            theReturn << std::string((const char *)chunk.data()+sizeof(pi_uint16_t));
//            theReturn << std::string((const char *)chunk.data()+sizeof(pi_uint16_t), chunk.size() - 2);
            theReturn << charSeperator;
            theReturn << PalmLib::get_short(chunk.data() + sizeof(pi_uint16_t) + 32 * sizeof(pi_char_t));
        break;

        case PalmLib::FlatFile::Field::LINKED:
            theReturn << PalmLib::get_short(chunk.data() + sizeof(pi_uint16_t));
            theReturn << charSeperator;
            theReturn << PalmLib::get_short(chunk.data() + 2 * sizeof(pi_uint16_t));
        break;

        case PalmLib::FlatFile::Field::CALCULATED:
        break;

        default:
            kdDebug() << "unknown field type" << endl;
            break;
        }
    }
    return std::string(theReturn.str());
}

void PalmLib::FlatFile::DB::extract_aboutinfo()
{
    if (!has_key(m_chunks, CHUNK_ABOUT))
        return;

    Chunk chunk = m_chunks[CHUNK_ABOUT][0];
    pi_char_t* header = chunk.data();
    pi_char_t* q = chunk.data() + PalmLib::get_short(header);

    setAboutInformation( (char*)q);
}

void PalmLib::FlatFile::DB::parse_record(PalmLib::Record& record,
                                         std::vector<pi_char_t *>& ptrs,
                                         std::vector<size_t>& sizes)
{
    unsigned i;

    // Ensure that enough space for the offset table exists.
    if (record.size() < getNumOfFields() * sizeof(pi_uint16_t)) {
//        throw PalmLib::error("record is corrupt");
        kdDebug() << "record is corrupt" << endl;
    }
    // Extract the offsets from the record. Determine field pointers.
    std::vector<pi_uint16_t> offsets(getNumOfFields());
    for (i = 0; i < getNumOfFields(); ++i) {
        offsets[i] = get_short(record.data() + i * sizeof(pi_uint16_t));
        if (offsets[i] >= record.size()) {
//            throw PalmLib::error("record is corrupt");
            kdDebug() << "record is corrupt" << endl;
        }
        ptrs.push_back(record.data() + offsets[i]);
    }

    // Determine the field sizes.
    for (i = 0; i < getNumOfFields() - 1; ++i) {
        sizes.push_back(offsets[i + 1] - offsets[i]);
    }
    sizes.push_back(record.size() - offsets[getNumOfFields() - 1]);
}

PalmLib::FlatFile::DB::DB(PalmLib::Database& pdb)
    : Database("db", pdb), m_flags(0)
{
    // Split the application information block into its component chunks.
    extract_chunks(pdb.getAppInfoBlock());

    // Pull the header fields and schema out of the databasse.
    m_flags = get_short(pdb.getAppInfoBlock().data());
    unsigned numFields = get_short(pdb.getAppInfoBlock().data() + 2);
    extract_schema(numFields);

    // Extract all of the list views.
    extract_listviews();

    extract_aboutinfo();

    for (unsigned i = 0; i < pdb.getNumRecords(); ++i) {
        PalmLib::Record record = pdb.getRecord(i);
        Record rec;

            std::vector<pi_char_t *> ptrs;
            std::vector<size_t> sizes;
            parse_record(record, ptrs, sizes);
            for (unsigned j = 0; j < getNumOfFields(); ++j) {
                PalmLib::FlatFile::Field f;
        f.type = field_type(j);

                switch (field_type(j)) {
                case PalmLib::FlatFile::Field::STRING:
                            f.type = PalmLib::FlatFile::Field::STRING;
                            f.v_string = std::string((char *) ptrs[j], sizes[j] - 1);
                    break;

                case PalmLib::FlatFile::Field::BOOLEAN:
                            f.type = PalmLib::FlatFile::Field::BOOLEAN;
                            if (*(ptrs[j]))
                                f.v_boolean = true;
                            else
                                f.v_boolean = false;
                    break;

                case PalmLib::FlatFile::Field::INTEGER:
                            f.type = PalmLib::FlatFile::Field::INTEGER;
                            f.v_integer = PalmLib::get_long(ptrs[j]);
                break;

                case PalmLib::FlatFile::Field::FLOAT: {
                            // Place data from database in a union for conversion.
                            pi_double_t value;
                            value.words.hi = PalmLib::get_long(ptrs[j]);
                            value.words.lo = PalmLib::get_long(ptrs[j] + 4);

                            // Fill out the information for this field.
                            f.type = PalmLib::FlatFile::Field::FLOAT;
                            f.v_float = value.number;
                    }
                break;

                    case PalmLib::FlatFile::Field::DATE:
                            f.type = PalmLib::FlatFile::Field::DATE;
                            f.v_date.year = PalmLib::get_short(ptrs[j]);
                            f.v_date.month = static_cast<int> (*(ptrs[j] + 2));
                            f.v_date.day = static_cast<int> (*(ptrs[j] + 3));
                break;

                    case PalmLib::FlatFile::Field::TIME:
                            f.type = PalmLib::FlatFile::Field::TIME;
                            f.v_time.hour = static_cast<int> (*(ptrs[j]));
                            f.v_time.minute = static_cast<int> (*(ptrs[j] + 1));
                break;

                case PalmLib::FlatFile::Field::NOTE:
                            f.type = PalmLib::FlatFile::Field::NOTE;
                            f.v_string = std::string((char *) ptrs[j], sizes[j] - 3);
                            f.v_note = std::string((char *) (record.data() + get_short(ptrs[j] + strlen(f.v_string.c_str()) + 1)));
                break;

                case PalmLib::FlatFile::Field::LIST:
                            f.type = PalmLib::FlatFile::Field::LIST;
                if (!field(j).argument().empty()) {
                    std::string data = field(j).argument();
                    unsigned int k;
                    std::string::size_type pos = 0;
                    pi_uint16_t itemID = *ptrs[j]; // TR: a list value is stored on 1 byte

                    for (k = 0; k < itemID; k++) {
                        if ((pos = data.find(charSeperator, pos)) == std::string::npos) {
                            break;
                        }
                        pos++;
                    }
                    if (pos == std::string::npos) {
                        f.v_string = "N/A";
                    } else {
                        if (data.find(charSeperator, pos) == std::string::npos) {
                            f.v_string = data.substr( pos, std::string::npos);
                        } else {
                            f.v_string = data.substr( pos, data.find(charSeperator, pos) - pos);
            }
                    }
                }
                break;

                case PalmLib::FlatFile::Field::LINK:
                            f.type = PalmLib::FlatFile::Field::LINK;
                            f.v_integer = PalmLib::get_long(ptrs[j]);
                            f.v_string = std::string((char *) (ptrs[j] + 4), sizes[j] - 5);
                break;

                case PalmLib::FlatFile::Field::LINKED:
                            f.type = PalmLib::FlatFile::Field::LINKED;
                            f.v_string = std::string((char *) ptrs[j], sizes[j] - 1);
                break;

                case PalmLib::FlatFile::Field::CALCULATED: {
                std::ostringstream value;
                            f.type = PalmLib::FlatFile::Field::CALCULATED;
                switch (ptrs[j][0]) {
                case 1: //string
                    value << std::string((char *) ptrs[j] + 1, sizes[j] - 2);
                break;
                case 2: //integer
                    value << PalmLib::get_long(ptrs[j] + 1);
                break;
                case 9: //float
                {
                    pi_double_t fvalue;
                    fvalue.words.hi = PalmLib::get_long(ptrs[j] + 1);
                    fvalue.words.lo = PalmLib::get_long(ptrs[j] + 5);

                    value << fvalue.number;
                    }
                default:
                    value << "N/A";
                }
                f.v_string = value.str();
                } break;

                    default:
                            kdDebug() << "unknown field type" << endl;
                            break;
            }

            // Append this field to the record.
            rec.appendField(f);
        }
        rec.unique_id(record.unique_id());
        // Append this record to the database.
        appendRecord(rec);
    }
}

void PalmLib::FlatFile::DB::make_record(PalmLib::Record& pdb_record,
                                        const Record& record) const
{
  unsigned int i;

    // Determine the packed size of this record.
    size_t size = getNumOfFields() * sizeof(pi_uint16_t);
    for (i = 0; i < getNumOfFields(); i++) {
#ifdef HAVE_VECTOR_AT
  const Field field = record.fields().at(i);
#else
  const Field field = record.fields()[i];
#endif
        switch (field.type) {
        case PalmLib::FlatFile::Field::STRING:
            size += field.v_string.length() + 1;
            break;

        case PalmLib::FlatFile::Field::NOTE:
            size += field.v_string.length() + 3;
        size += field.v_note.length() + 1;
            break;

        case PalmLib::FlatFile::Field::BOOLEAN:
            size += 1;
            break;

        case PalmLib::FlatFile::Field::INTEGER:
            size += 4;
            break;

        case PalmLib::FlatFile::Field::FLOAT:
            size += 8;
            break;

        case PalmLib::FlatFile::Field::DATE:
            size += sizeof(pi_uint16_t) + 2 * sizeof(pi_char_t);
            break;

        case PalmLib::FlatFile::Field::TIME:
            size += 2 * sizeof(pi_char_t);
            break;

        case PalmLib::FlatFile::Field::LIST:
            size += sizeof(pi_char_t);
            break;

        case PalmLib::FlatFile::Field::LINK:
            size += sizeof(pi_int32_t);
            size += field.v_string.length() + 1;
            break;

        case PalmLib::FlatFile::Field::LINKED:
            size += field.v_string.length() + 1;
            break;

    case PalmLib::FlatFile::Field::CALCULATED:
        size += 1;
        break;

        default:
            kdDebug() << "unsupported field type" << endl;
            break;
        }
    }

    // Allocate a block for the packed record and setup the pointers.
    pi_char_t* buf = new pi_char_t[size];
    pi_char_t* p = buf + getNumOfFields() * sizeof(pi_uint16_t);
    pi_char_t* offsets = buf;

    // Pack the fields into the buffer.
    for (i = 0; i < getNumOfFields(); i++) {
    pi_char_t* noteOffsetOffset = 0;
    bool setNote = false;
#ifdef HAVE_VECTOR_AT
    const Field fieldData = record.fields().at(i);
#else
    const Field fieldData = record.fields()[i];
#endif

        // Mark the offset to the start of this field in the offests table.
        PalmLib::set_short(offsets, static_cast<pi_uint16_t> (p - buf));
        offsets += sizeof(pi_uint16_t);

        // Pack the field.
        switch (fieldData.type) {
        case PalmLib::FlatFile::Field::STRING:
            memcpy(p, fieldData.v_string.c_str(), fieldData.v_string.length() + 1);
            p += fieldData.v_string.length() + 1;
            break;

        case PalmLib::FlatFile::Field::NOTE:
          if (setNote)
            kdDebug() << "unsupported field type";
            memcpy(p, fieldData.v_string.c_str(), fieldData.v_string.length() + 1);
            p += fieldData.v_string.length() + 1;
            noteOffsetOffset = p;
            p += 2;
            setNote = true;
            break;

        case PalmLib::FlatFile::Field::BOOLEAN:
            *p++ = ((fieldData.v_boolean) ? 1 : 0);
            break;

        case PalmLib::FlatFile::Field::INTEGER:
            PalmLib::set_long(p, fieldData.v_integer);
            p += sizeof(pi_int32_t);
            break;

        case PalmLib::FlatFile::Field::FLOAT: {
            // Place data the data in a union for easy conversion.
            pi_double_t value;
            value.number = fieldData.v_float;
            PalmLib::set_long(p, value.words.hi);
            p += sizeof(pi_uint32_t);
            PalmLib::set_long(p, value.words.lo);
            p += sizeof(pi_uint32_t);
            break;
        }

        case PalmLib::FlatFile::Field::DATE:
            PalmLib::set_short(p, fieldData.v_date.year);
            p += sizeof(pi_uint16_t);
            *p++ = static_cast<pi_char_t> (fieldData.v_date.month & 0xFF);
            *p++ = static_cast<pi_char_t> (fieldData.v_date.day & 0xFF);
            break;

        case PalmLib::FlatFile::Field::TIME:
            *p++ = static_cast<pi_char_t> (fieldData.v_time.hour & 0xFF);
            *p++ = static_cast<pi_char_t> (fieldData.v_time.minute & 0xFF);
            break;

        case PalmLib::FlatFile::Field::LIST:
        if (!field(i).argument().empty()) {
            std::string data = field(i).argument();
            std::string::size_type pos = 0, next;
            unsigned int j = 0;
            pi_int16_t itemID = -1;

            while ( (next = data.find(charSeperator, pos)) != std::string::npos) {
                if (fieldData.v_string == data.substr( pos, next - pos)) {
                    itemID = j;
                    break;
                }
                j++;
                pos = next + 1;
            }
      // TR: the following test handles the case where the field value
      // equals the last item in list (bugfix)
            if (itemID == -1 && fieldData.v_string == data.substr( pos, std::string::npos)) {
                itemID = j;
            }
            p[0] = itemID; // TR: a list value is stored on 1 byte
            p += sizeof(pi_char_t);
        }
            break;

        case PalmLib::FlatFile::Field::LINK:
            PalmLib::set_long(p, fieldData.v_integer);
            p += sizeof(pi_int32_t);
            memcpy(p, fieldData.v_string.c_str(), fieldData.v_string.length() + 1);
            p += fieldData.v_string.length() + 1;
            break;

        case PalmLib::FlatFile::Field::LINKED:
            memcpy(p, fieldData.v_string.c_str(), fieldData.v_string.length() + 1);
            p += fieldData.v_string.length() + 1;
            break;

    case PalmLib::FlatFile::Field::CALCULATED:
        *p = 13;
        p++;
        break;

        default:
            kdDebug() << "unsupported field type";
            break;
        }
    if (setNote) {
        if (fieldData.v_note.length()) {
                memcpy(p, fieldData.v_note.c_str(), fieldData.v_note.length() + 1);
                PalmLib::set_short(noteOffsetOffset, (pi_uint16_t)(p - buf));
                p += fieldData.v_note.length() + 1;
        } else {
                PalmLib::set_short(noteOffsetOffset, 0);
        }
    }
    }

    // Place the packed data into the PalmOS record.
    pdb_record.set_raw(buf, size);
    delete [] buf;
}

void PalmLib::FlatFile::DB::build_fieldsdata_chunks(std::vector<DB::Chunk>& chunks) const
{
    pi_char_t * buf = 0, * p;
    unsigned int size, i;

    for (i = 0; i < getNumOfFields(); ++i) {
        size = 0;
        switch (field_type(i)) {
        case PalmLib::FlatFile::Field::STRING:
            if (!field(i).argument().empty()) {
                size = (field(i).argument().length() + 1) + 2;
                buf = new pi_char_t[size];
                PalmLib::set_short(buf, i);
                strcpy((char *) (buf + 2), field(i).argument().c_str());
            }
        break;

        case PalmLib::FlatFile::Field::BOOLEAN:
        break;

        case PalmLib::FlatFile::Field::INTEGER:
            if (!field(i).argument().empty()) {
                std::string data = field(i).argument();
                std::pair< PalmLib::pi_int32_t, PalmLib::pi_int16_t> values(0, 0);

                if ( data.find(charSeperator) != std::string::npos) {
                    StrOps::convert_string(data.substr( 0, data.find(charSeperator)), values.first);
                    StrOps::convert_string(data.substr( data.find(charSeperator) + 1, std::string::npos), values.second);
                } else
                    StrOps::convert_string(data, values.first);

                size = 2 + sizeof(pi_uint32_t) + sizeof(pi_uint16_t);
                buf = new pi_char_t[size];
                p = buf;
                PalmLib::set_short(p, i);
                p += sizeof(pi_uint16_t);
                    PalmLib::set_long(p, values.first);
                    p += sizeof(pi_uint32_t);
                    PalmLib::set_short(p, values.second);
                    p += sizeof(pi_uint16_t);
            }
        break;

        case PalmLib::FlatFile::Field::FLOAT:
            if (!field(i).argument().empty()) {
                std::string data = field(i).argument();
                pi_double_t value;

                StrOps::convert_string(data, value.number);

                size = 2 + 2 * sizeof(pi_uint32_t);
                buf = new pi_char_t[size];
                p = buf;
                PalmLib::set_short(p, i);
                p += sizeof(pi_uint16_t);
                PalmLib::set_long(p, value.words.hi);
                p += sizeof(pi_uint32_t);
                PalmLib::set_long(p, value.words.lo);
                p += sizeof(pi_uint32_t);
            }
        break;

        case PalmLib::FlatFile::Field::DATE:
            if (!field(i).argument().empty()) {
                std::string data = field(i).argument();
                struct tm date;
                pi_char_t type;

                if (data.substr(0, 3) == "now") {
                    type = NOW_DEFAULT;
                            const struct tm * tm_ptr;
                            time_t now;

                            time(&now);
                            tm_ptr = localtime(&now);
                            memcpy(&date, tm_ptr, sizeof(tm));
                } else
#ifdef strptime
                    if (strptime(data.c_str(), "%Y/%m/%d", &date))
#else
                    if (StrOps::strptime(data.c_str(), "%Y/%m/%d", &date))
#endif
                    type = CONSTANT_DEFAULT;
                else
                    type = INVALID_DEFAULT;

                if (type != INVALID_DEFAULT) {
                    size = sizeof(pi_uint16_t) + 1 + sizeof(pi_uint16_t) + 2;
                    buf = new pi_char_t[size];
                    p = buf;
                    PalmLib::set_short(p, i);
                    p += sizeof(pi_uint16_t);
                    *p++ = static_cast<pi_char_t> (type & 0xFF);
                    PalmLib::set_short(p, date.tm_year + 1900);
                    p += sizeof(pi_uint16_t);
                    *p++ = static_cast<pi_char_t> ((date.tm_mon + 1) & 0xFF);
                    *p++ = static_cast<pi_char_t> (date.tm_mday & 0xFF);
                }

            }
        break;

        case PalmLib::FlatFile::Field::TIME:
            if (!field(i).argument().empty()) {
                std::string data = field(i).argument();
                struct tm t;
                pi_char_t type;

                if (data == "now") {
                    type = NOW_DEFAULT;
                    const struct tm * tm_ptr;
                    time_t now;

                    time(&now);
                    tm_ptr = localtime(&now);
                    memcpy(&t, tm_ptr, sizeof(tm));
                } else
#ifdef strptime
                if (!strptime(data.c_str(), "%H/%M", &t))
#else
                if (!StrOps::strptime(data.c_str(), "%H/%M", &t))
#endif
                    type = CONSTANT_DEFAULT;
                else
                    type = INVALID_DEFAULT;

                if (type != INVALID_DEFAULT) {
                    size = sizeof(pi_uint16_t) + 1 + sizeof(pi_uint16_t) + 2;
                    buf = new pi_char_t[size];
                    p = buf;
                    PalmLib::set_short(p, i);
                    p += sizeof(pi_uint16_t);
                    *p++ = static_cast<pi_char_t> (type & 0xFF);
                    *p++ = static_cast<pi_char_t> (t.tm_hour & 0xFF);
                    *p++ = static_cast<pi_char_t> (t.tm_min & 0xFF);
                }

            }
        break;

        case PalmLib::FlatFile::Field::NOTE:
        break;

        case PalmLib::FlatFile::Field::LIST:
            if (!field(i).argument().empty()) {
                std::string data = field(i).argument();
                std::vector<std::string> items;
                std::string::size_type pos = 0, next;
                std::vector<std::string>::iterator iter;
                size = 2 + 2 * sizeof(pi_uint16_t);
                while ( (next = data.find(charSeperator, pos)) != std::string::npos) {
                    std::string item = data.substr( pos, next - pos);
                    items.push_back(item);
                    size += item.length() + 1;
                    pos = next + 1;
                }
                if (pos != std::string::npos) {
                    std::string item = data.substr( pos, std::string::npos);
                    items.push_back(item);
                    size += item.length() + 1;
                }

                buf = new pi_char_t[size];
                p = buf;
                PalmLib::set_short(p, i);
                p += sizeof(pi_uint16_t);
                PalmLib::set_short(p, items.size());
                p += sizeof(pi_uint16_t);
                p += sizeof(pi_uint16_t);
                for (iter = items.begin(); iter != items.end(); ++iter) {
                    std::string& item = (*iter);
                    strcpy((char *) p, item.c_str());
                    p[item.length()] = 0;
                    p += item.length() + 1;
                }

            }
        break;

        case PalmLib::FlatFile::Field::LINK:
            if (!field(i).argument().empty()) {
                std::string data = field(i).argument();
                std::string databasename;
                pi_uint16_t fieldnum;

                if ( data.find(charSeperator) != std::string::npos) {
                    databasename = data.substr( 0, data.find(charSeperator));
                    StrOps::convert_string(data.substr( data.find(charSeperator) + 1, std::string::npos), fieldnum);
                } else {
                    databasename = data;
                    fieldnum = 0;
                }

                size = 2 + 32 * sizeof(pi_char_t) + sizeof(pi_uint16_t);
                buf = new pi_char_t[size];
                p = buf;
                PalmLib::set_short(p, i);
                p += sizeof(pi_uint16_t);
                strcpy((char *) p, databasename.c_str());
                p += 32 * sizeof(pi_char_t);
                PalmLib::set_short(p, fieldnum);
                p += sizeof(pi_uint16_t);
            }
        break;

        case PalmLib::FlatFile::Field::LINKED:
            if (!field(i).argument().empty()) {
                std::string data = field(i).argument();
                pi_uint16_t linknum;
                pi_uint16_t fieldnum;

                if ( data.find(charSeperator) != std::string::npos) {
                    StrOps::convert_string(data.substr( 0, data.find(charSeperator)), linknum);
                    StrOps::convert_string(data.substr( data.find(charSeperator) + 1, std::string::npos), fieldnum);
                    if (field_type(linknum) != PalmLib::FlatFile::Field::LINK) {
                        unsigned int j = 0;
                        while (field_type(j) != PalmLib::FlatFile::Field::LINK && j < i) j++;
                        linknum = j;
                    }
                } else {
                    unsigned int j = 0;
                    while (field_type(j) != PalmLib::FlatFile::Field::LINK && j < i) j++;
                    linknum = j;
                    fieldnum = 0;
                }

                size = 2 + 2 *  sizeof(pi_uint16_t);
                buf = new pi_char_t[size];
                p = buf;
                PalmLib::set_short(p, i);
                p += sizeof(pi_uint16_t);
                       PalmLib::set_short(p, linknum);
                    p += sizeof(pi_uint16_t);
                       PalmLib::set_short(p, fieldnum);
                    p += sizeof(pi_uint16_t);
            }
        break;

        case PalmLib::FlatFile::Field::CALCULATED:
        break;

        default:
            kdDebug() << "unknown field type" << endl;
            break;
        }

        if (size) {
            Chunk data_chunk(buf, size);
            data_chunk.chunk_type = CHUNK_FIELD_DATA;
            delete [] buf;
            chunks.push_back(data_chunk);
        }
    }
}

void PalmLib::FlatFile::DB::build_about_chunk(std::vector<DB::Chunk>& chunks) const
{
    pi_char_t* buf;
    pi_char_t* p;
    int headersize = 2*sizeof(pi_uint16_t);
    std::string information = getAboutInformation();

    if (!information.length())
        return;
    // Build the names chunk.
    buf = new pi_char_t[headersize + information.length() + 1];
    p = buf;

    PalmLib::set_short(p, headersize);
    p += 2;
    PalmLib::set_short(p, 1); //about type version
    p += 2;
    memcpy(p, information.c_str(), information.length() + 1);
    p += information.length() + 1;
    Chunk chunk(buf, headersize + information.length() + 1);
    chunk.chunk_type = CHUNK_ABOUT;
    delete [] buf;
    chunks.push_back(chunk);

}

void PalmLib::FlatFile::DB::build_standard_chunks(std::vector<DB::Chunk>& chunks) const
{
    pi_char_t* buf;
    pi_char_t* p;
    unsigned i;

    // Determine the size needed for the names chunk.
    size_t names_chunk_size = 0;
    for (i = 0; i < getNumOfFields(); ++i) {
        names_chunk_size += field_name(i).length() + 1;
    }

    // Build the names chunk.
    buf = new pi_char_t[names_chunk_size];
    p = buf;
    for (i = 0; i < getNumOfFields(); ++i) {
        const std::string name = field_name(i);
        memcpy(p, name.c_str(), name.length() + 1);
        p += name.length() + 1;
    }
    Chunk names_chunk(buf, names_chunk_size);
    names_chunk.chunk_type = CHUNK_FIELD_NAMES;
    delete [] buf;

    // Build the types chunk.
    buf = new pi_char_t[getNumOfFields() * sizeof(pi_uint16_t)];
    p = buf;
    for (i = 0; i < getNumOfFields(); ++i) {
        // Pack the type of the current field.
        switch (field_type(i)) {
        case PalmLib::FlatFile::Field::STRING:
            PalmLib::set_short(p, 0);
            break;

        case PalmLib::FlatFile::Field::BOOLEAN:
            PalmLib::set_short(p, 1);
            break;

        case PalmLib::FlatFile::Field::INTEGER:
            PalmLib::set_short(p, 2);
            break;

        case PalmLib::FlatFile::Field::DATE:
            PalmLib::set_short(p, 3);
            break;

        case PalmLib::FlatFile::Field::TIME:
            PalmLib::set_short(p, 4);
            break;

        case PalmLib::FlatFile::Field::NOTE:
            PalmLib::set_short(p, 5);
            break;

        case PalmLib::FlatFile::Field::LIST:
            PalmLib::set_short(p, 6);
            break;

        case PalmLib::FlatFile::Field::LINK:
            PalmLib::set_short(p, 7);
            break;

        case PalmLib::FlatFile::Field::FLOAT:
            PalmLib::set_short(p, 8);
            break;

        case PalmLib::FlatFile::Field::CALCULATED:
            PalmLib::set_short(p, 9);
            break;

        case PalmLib::FlatFile::Field::LINKED:
            PalmLib::set_short(p, 10);
            break;

        default:
            kdDebug() << "unsupported field type" << endl;
            break;
        }

        // Advance to the next position.
        p += sizeof(pi_uint16_t);
    }
    Chunk types_chunk(buf, getNumOfFields() * sizeof(pi_uint16_t));
    types_chunk.chunk_type = CHUNK_FIELD_TYPES;
    delete [] buf;

    // Build the list view options chunk.
    buf = new pi_char_t[2 * sizeof(pi_uint16_t)];
    PalmLib::set_short(buf, 0);
    PalmLib::set_short(buf + sizeof(pi_uint16_t), 0);
    Chunk listview_options_chunk(buf, 2 * sizeof(pi_uint16_t));
    listview_options_chunk.chunk_type = CHUNK_LISTVIEW_OPTIONS;
    delete [] buf;

    // Build the local find options chunk.
    buf = new pi_char_t[sizeof(pi_uint16_t)];
    PalmLib::set_short(buf, 0);
    Chunk lfind_options_chunk(buf, 1 * sizeof(pi_uint16_t));
    lfind_options_chunk.chunk_type = CHUNK_LFIND_OPTIONS;
    delete [] buf;

    // Add all the chunks to the chunk list.
    chunks.push_back(names_chunk);
    chunks.push_back(types_chunk);
    chunks.push_back(listview_options_chunk);
    chunks.push_back(lfind_options_chunk);
}

void PalmLib::FlatFile::DB::build_listview_chunk(std::vector<DB::Chunk>& chunks,
                                                 const ListView& lv) const
{
    // Calculate size and allocate space for the temporary buffer.
    size_t size = 2 * sizeof(pi_uint16_t) + 32
        + lv.size() * (2 * sizeof(pi_uint16_t));
    pi_char_t* buf = new pi_char_t[size];

    // Fill in the header details.
  pi_uint16_t flags = 0;
  if (lv.editoruse) {
    std::cout << "editoruse\n";
    flags |= VIEWFLAG_USE_IN_EDITVIEW;
  }
    PalmLib::set_short(buf, flags);
    PalmLib::set_short(buf + sizeof(pi_uint16_t), lv.size());
    memset((char *) (buf + 4), 0, 32);
    strncpy((char *) (buf + 4), lv.name.c_str(), 32);

    // Fill in the column details.
    pi_char_t* p = buf + 4 + 32;
    for (ListView::const_iterator i = lv.begin(); i != lv.end(); ++i) {
        const ListViewColumn& col = (*i);
        PalmLib::set_short(p, col.field);
        PalmLib::set_short(p + sizeof(pi_uint16_t), col.width);
        p += 2 * sizeof(pi_uint16_t);
    }

    // Create the chunk and place it in the chunks list.
    Chunk chunk(buf, size);
    chunk.chunk_type = CHUNK_LISTVIEW_DEFINITION;
    delete [] buf;
    chunks.push_back(chunk);
}

void PalmLib::FlatFile::DB::build_appinfo_block(const std::vector<DB::Chunk>& chunks, PalmLib::Block& appinfo) const
{
    std::vector<Chunk>::const_iterator iter;

    // Determine the size of the final app info block.
    size_t size = 2 * sizeof(pi_uint16_t);
    for (iter = chunks.begin(); iter != chunks.end(); ++iter) {
        const Chunk& chunk = (*iter);
        size += 2 * sizeof(pi_uint16_t) + chunk.size();
    }

    // Allocate the temporary buffer. Fill in the header.
    pi_char_t* buf = new pi_char_t[size];
    PalmLib::set_short(buf, m_flags);
    PalmLib::set_short(buf + sizeof(pi_uint16_t), getNumOfFields());

    // Pack the chunks into the buffer.
    size_t i = 4;
    for (iter = chunks.begin(); iter != chunks.end(); ++iter) {
        const Chunk& chunk = (*iter);
        // Set the chunk type and size.
        PalmLib::set_short(buf + i, chunk.chunk_type);
        PalmLib::set_short(buf + i + 2, chunk.size());
        i += 4;

        // Copy the chunk data into the buffer.
        memcpy(buf + i, chunk.data(), chunk.size());
        i += chunk.size();
    }

    // Finally, move the buffer into the provided appinfo block.
    appinfo.set_raw(buf, size);
    delete [] buf;
}

void PalmLib::FlatFile::DB::outputPDB(PalmLib::Database& pdb) const
{
    unsigned i;

    // Let the superclass have a chance.
    SUPERCLASS(PalmLib::FlatFile, Database, outputPDB, (pdb));

    // Set the database's type and creator.
    pdb.type(PalmLib::mktag('D','B','0','0'));
    pdb.creator(PalmLib::mktag('D','B','O','S'));

    // Create the app info block.
    std::vector<Chunk> chunks;
    build_standard_chunks(chunks);
    for (i = 0; i < getNumOfListViews(); ++i) {
        build_listview_chunk(chunks, getListView(i));
    }
    build_fieldsdata_chunks(chunks);
    build_about_chunk(chunks);

    PalmLib::Block appinfo;
    build_appinfo_block(chunks, appinfo);
    pdb.setAppInfoBlock(appinfo);

    // Output each record to the PalmOS database.
    for (i = 0; i < getNumRecords(); ++i) {
        Record record = getRecord(i);
        PalmLib::Record pdb_record;

        make_record(pdb_record, record);
        pdb.appendRecord(pdb_record);
    }
}

unsigned PalmLib::FlatFile::DB::getMaxNumOfFields() const
{
    return 0;
}

bool
PalmLib::FlatFile::DB::supportsFieldType(const Field::FieldType& type) const
{
    switch (type) {
        case PalmLib::FlatFile::Field::STRING:
        case PalmLib::FlatFile::Field::BOOLEAN:
        case PalmLib::FlatFile::Field::INTEGER:
        case PalmLib::FlatFile::Field::FLOAT:
        case PalmLib::FlatFile::Field::DATE:
        case PalmLib::FlatFile::Field::TIME:
        case PalmLib::FlatFile::Field::NOTE:
        case PalmLib::FlatFile::Field::LIST:
        case PalmLib::FlatFile::Field::LINK:
        case PalmLib::FlatFile::Field::LINKED:
        case PalmLib::FlatFile::Field::CALCULATED:
        return true;
    default:
        return false;
    }
}

std::vector<std::string>
PalmLib::FlatFile::DB::field_argumentf(int i, std::string& format)
{
    std::vector<std::string> vtitles(0, std::string(""));
        int j;

    switch (field_type(i)) {
    case PalmLib::FlatFile::Field::STRING:
        format = std::string("%s");
        vtitles.push_back(std::string("default value"));
    break;
    case PalmLib::FlatFile::Field::INTEGER:
        format = std::string("%ld/%d");
        vtitles.push_back(std::string("default value"));
        vtitles.push_back(std::string("increment"));
    break;
    case PalmLib::FlatFile::Field::FLOAT:
        format = std::string("%f");
        vtitles.push_back(std::string("default value"));
    break;
    case PalmLib::FlatFile::Field::DATE:
        format = std::string("%d/%d/%d");
        vtitles.push_back(std::string("Year (or now)"));
        vtitles.push_back(std::string("Month"));
        vtitles.push_back(std::string("Day in the month"));
    break;
    case PalmLib::FlatFile::Field::TIME:
        format = std::string("%d/%d");
        vtitles.push_back(std::string("Hour (or now)"));
        vtitles.push_back(std::string("Minute"));
    break;
        case PalmLib::FlatFile::Field::LIST:
        format = std::string("");
        for (j = 0; j < 31; i++) {
            format += std::string("%s/");
            std::ostringstream  title;
            title << "item " << j;
            vtitles.push_back(title.str());
        }
        format += std::string("%s");
        vtitles.push_back(std::string("item 32"));
    break;
        case PalmLib::FlatFile::Field::LINK:
        format = std::string("%s/%d");
        vtitles.push_back(std::string("database"));
        vtitles.push_back(std::string("field number"));
    break;
        case PalmLib::FlatFile::Field::LINKED:
        format = std::string("%d/%d");
        vtitles.push_back(std::string("link field number"));
        vtitles.push_back(std::string("field number"));
    break;
        case PalmLib::FlatFile::Field::CALCULATED:
    case PalmLib::FlatFile::Field::BOOLEAN:
        case PalmLib::FlatFile::Field::NOTE:
    default:
        format = std::string("");
    break;
    }
    return vtitles;
}

unsigned PalmLib::FlatFile::DB::getMaxNumOfListViews() const
{
    return 0;
}

void PalmLib::FlatFile::DB::doneWithSchema()
{
    // Let the superclass have a chance.
    SUPERCLASS(PalmLib::FlatFile, Database, doneWithSchema, ());
/* false from the 0.3.3 version
    if (getNumOfListViews() < 1)
        throw PalmLib::error("at least one list view must be specified");
*/
}

void PalmLib::FlatFile::DB::setOption(const std::string& name,
                                      const std::string& value)
{
    if (name == "find") {
        if (!StrOps::string2boolean(value))
            m_flags &= ~(1);
        else
            m_flags |= 1;
    } else if (name == "read-only"
                || name == "readonly") {
        if (!StrOps::string2boolean(value))
            m_flags &= ~(0x8000);
        else
            m_flags |= 0x8000;
    } else {
        SUPERCLASS(PalmLib::FlatFile, Database, setOption, (name, value));
    }
}

PalmLib::FlatFile::Database::options_list_t
PalmLib::FlatFile::DB::getOptions(void) const
{
    typedef PalmLib::FlatFile::Database::options_list_t::value_type value;
    PalmLib::FlatFile::Database::options_list_t result;

    result = SUPERCLASS(PalmLib::FlatFile, Database, getOptions, ());

    if (m_flags & 1)
        result.push_back(value("find", "true"));

    if (m_flags & 0x8000)
        result.push_back(value("read-only", "true"));

    return result;
}