/*
* Copyright 2010, Haiku. All rights reserved.
* Distributed under the terms of the MIT License.
*
* Authors:
*               Michael Pfeiffer
*/
#include "GPBinding.h"

#include <list>
#include <set>
#include <string>

#include <gutenprint/gutenprint.h>


#include "GPCapabilityExtractor.h"

using namespace std;


// printer manufacturer
static const char* kManufacturerId = "id";
static const char* kManufacturerDisplayName = "name";

// printer model
static const char* kModelDisplayName = "model";
static const char* kModelDriver = "driver";


GPBinding::GPBinding()
:
fInitialized(false),
fOutputStream(NULL)
{

}


GPBinding::~GPBinding()
{
        DeleteBands();
}


status_t
GPBinding::GetPrinterManufacturers(BMessage& manufacturers)
{
        InitGutenprint();

        list<string> ids;
        set<string> manufacturerSet;

        for (int i = 0; i < stp_printer_model_count(); i ++) {
                const stp_printer_t* printer = stp_get_printer_by_index(i);
                string manufacturer = stp_printer_get_manufacturer(printer);

                // ignore unnamed manufacturers
                if (manufacturer == "")
                        continue;

                // add manufacturer only once
                if (manufacturerSet.find(manufacturer) != manufacturerSet.end())
                        continue;

                manufacturerSet.insert(manufacturer);

                ids.push_back(manufacturer);
        }

        ids.sort();

        list<string>::iterator it = ids.begin();
        for (; it != ids.end(); it ++) {
                string manufacturer = *it;
                const char* id = manufacturer.c_str();
                const char* name = manufacturer.c_str();
                AddManufacturer(manufacturers, id, name);
        }
        return B_OK;
}


bool
GPBinding::ExtractManufacturer(const BMessage& manufacturers, int32 index,
        BString& id, BString& displayName)
{
        if (manufacturers.FindString(kManufacturerId, index, &id) != B_OK)
                return false;
        if (manufacturers.FindString(kManufacturerDisplayName, index, &displayName)
                != B_OK)
                return false;
        return true;
}


void
GPBinding::AddManufacturer(BMessage& manufacturers, const char* id,
        const char* displayName)
{
        manufacturers.AddString(kManufacturerId, id);
        manufacturers.AddString(kManufacturerDisplayName, displayName);
}


status_t
GPBinding::GetPrinterModels(const char* manufacturer, BMessage& models)
{
        for (int i = 0; i < stp_printer_model_count(); i ++) {
                const stp_printer_t* printer = stp_get_printer_by_index(i);
                if (strcmp(manufacturer, stp_printer_get_manufacturer(printer)) != 0)
                        continue;

                const char* displayName = stp_printer_get_long_name(printer);
                const char* driver = stp_printer_get_driver(printer);
                AddModel(models, displayName, driver);
        }
        return B_OK;
}


bool
GPBinding::ExtractModel(const BMessage& models, int32 index, BString& displayName,
        BString& driver)
{
        if (models.FindString(kModelDisplayName, index, &displayName) != B_OK)
                return false;
        if (models.FindString(kModelDriver, index, &driver) != B_OK)
                return false;
        return true;
}


void
GPBinding::AddModel(BMessage& models, const char* displayName,  const char* driver)
{
        models.AddString(kModelDisplayName, displayName);
        models.AddString(kModelDriver, driver);
}


status_t
GPBinding::GetCapabilities(const char* driver, GPCapabilities* capabilities)
{
        InitGutenprint();
        const stp_printer_t* printer = stp_get_printer_by_driver(driver);
        if (printer == NULL)
                return B_ERROR;

        GPCapabilityExtractor extractor(capabilities);
        extractor.Visit(printer);
        return B_OK;
}


status_t
GPBinding::BeginJob(GPJobConfiguration* configuration,
        OutputStream* outputStream)
{
        fOutputStream = outputStream;
        fJob.SetApplicationName("Gutenprint");
        fJob.SetConfiguration(configuration);
        fJob.SetOutputStream(outputStream);

        return fJob.Begin();
}


void
GPBinding::EndJob()
{
        fJob.End();
        fOutputStream = NULL;
}


void
GPBinding::BeginPage()
{
}


void
GPBinding::EndPage()
{
        status_t status = fJob.PrintPage(fBands);
        DeleteBands();
        if (status == B_IO_ERROR)
                throw TransportException("I/O Error");
        if (status == B_ERROR) {
                BString message;
                fJob.GetErrorMessage(message);
                throw TransportException(message.String());
        }
}


status_t
GPBinding::AddBitmapToPage(BBitmap* bitmap, BRect validRect, BPoint where)
{
        GPBand* band = new(nothrow) GPBand(bitmap, validRect, where);
        if (band == NULL) {
                return B_NO_MEMORY;
        }

        fBands.push_back(band);
        return B_OK;
}


void
GPBinding::InitGutenprint()
{
        if (fInitialized)
                return;
        fInitialized = true;
        // there is no "destroy" counter part so this creates memory leaks
        // this is no problem because the print server loads printer add-ons
        // in a new application instance that is terminated when not used anymore
        stp_init();
        stp_set_output_codeset("UTF-8");
}


void
GPBinding::DeleteBands()
{
        list<GPBand*>::iterator it = fBands.begin();
        for (; it != fBands.end(); it ++) {
                GPBand* band = *it;
                delete band;
        }
        fBands.clear();
}