/**
 ** Copyright (c) 2007-2009 Illumina, Inc.
 **
 ** This software is covered by the "Illumina Genome Analyzer Software
 ** License Agreement" and the "Illumina Source Code License Agreement",
 ** and certain third party copyright/licenses, and any user of this
 ** source file is bound by the terms therein (see accompanying files
 ** Illumina_Genome_Analyzer_Software_License_Agreement.pdf and
 ** Illumina_Source_Code_License_Agreement.pdf and third party
 ** copyright/license notices).
 **
 ** This file is part of the Consensus Assessment of Sequence And VAriation
 ** (CASAVA) software package.
 **
 ** \file XMLContentHandler.cpp
 **
 ** \brief Rudimentary XML content handler class similar to the Java org.xml.sax
 ** ContentHandler interface. An XML writer class based on this interface.
 **
 ** \author Klaus Maisinger
 **/

#if defined(__BORLANDC__)
#include <string.h>
#else
#include <cstring>
#endif
#include <cassert>
#include "common/XMLContentHandler.hh"

int Attributes::getLength() const
{
    return int(item_list.size());
}

int Attributes::getIndex(const std::string &name) const
{
    int i;
    for (i = 0; i < int(item_list.size()); i++)
        if (name == item_list[i].name)
            return i;
    return -1;
}

std::string Attributes::getName(int index) const
{
    return item_list[index].name;
}

std::string Attributes::getValue(int index) const
{
    if ((index >= 0) && (index < int(item_list.size())))
        return item_list[index].value;
    return "";
}

std::string Attributes::getValue(const std::string &name) const
{
    return getValue(getIndex(name));
}

void Attributes::addAttribute(const std::string &name,
							  const std::string &value)
{
    item_list.push_back(Item(name, value));
}

/************************************************************************/

XMLFileWriter::XMLFileWriter()
{
    fp = 0;
    iws = 0;
    iobuffer_ptr = 0;
    iobuffer_len = 50000;
    iobuffer = new char[iobuffer_len];
}

XMLFileWriter::XMLFileWriter(FILE *filehandle)
{
    XMLFileWriter();
    fp = filehandle;
}

XMLFileWriter::~XMLFileWriter()
{
    flush();
    if (iws != 0)
        delete[] iws;
    delete[] iobuffer;
}

void XMLFileWriter::setFileHandle(FILE *filehandle)
{
    flush();
    fp = filehandle;
    iobuffer_ptr = 0;
}

void XMLFileWriter::flush()
{
    if (iobuffer_ptr <= 0)
        return;
    int count = fprintf(fp, iobuffer);
    if (count < (int) strlen(iobuffer))
        fprintf(stderr, "XMLFileWriter: Failed to write output "
            "(%i of %i bytes written)\n", count, iobuffer_len);
    iobuffer_ptr = 0;
}

void XMLFileWriter::output(const char ch[])
{
    int len = (int) strlen(ch);
    if (len + iobuffer_ptr >= iobuffer_len)
        flush();
    if (len >= iobuffer_len)
    {
        int count = fprintf(fp, ch);
        if (count < len)
            fprintf(stderr, "XMLFileWriter: Failed to write output "
                "(%i of %i bytes written)\n", count, iobuffer_len);
    }
    else
    {
        snprintf(iobuffer + iobuffer_ptr, iobuffer_len - iobuffer_ptr, ch);
        iobuffer_ptr += len;
    }
}

void XMLFileWriter::writeWhitespace()
{
    if (iws)
    {
        output(iws);
        delete[] iws;
        iws = 0;
    }
}
/*
 * ignore the full Java API; no namespaces or qualified names
 */
void XMLFileWriter::startElement(const char name[], const Attributes *)
{
    writeWhitespace();
    char *buffer = new char[(strlen(name) + 3)];
    snprintf(buffer, strlen(name) + 3, "<%s>", name);
    output(buffer);
    delete[] buffer;
}

void XMLFileWriter::endElement(const char name[])
{
    writeWhitespace();
    char *buffer = new char[(strlen(name) + 4)];
    snprintf(buffer, strlen(name) + 4, "</%s>", name);
    output(buffer);
    delete[] buffer;
}

void XMLFileWriter::characters(const char ch[], int start, int length)
{
    assert(start < (int) strlen(ch));

    char *buffer = new char[length + 1];
    if (start + length > (int) strlen(ch))
        length = (int) strlen(ch) - start;
    memcpy(buffer, (void *) (ch + start), length * sizeof(char));
    buffer[length] = '\0';
    output(buffer);
    delete[] buffer;
}

void XMLFileWriter::ignorableWhitespace(const char ch[], int start, int length)
{
    if (start + length <= (int) strlen(ch))
    {
        if (iws)
            delete[] iws;
        iws = new char[length + 1];
        memcpy(iws, (void *) (ch + start), length * sizeof(char));
        iws[length] = '\0';
    }
}