/*
 * Lips4.cpp
 * Copyright 1999-2000 Y.Takagi. All Rights Reserved.
 */


#include "Lips4Cap.h"

#include <vector>

#include <Alert.h>
#include <Bitmap.h>
#include <File.h>

#include "DbgMsg.h"
#include "Halftone.h"
#include "JobData.h"
#include "Lips4.h"
#include "PackBits.h"
#include "PrinterData.h"
#include "ValidRect.h"


LIPS4Driver::LIPS4Driver(BMessage* message, PrinterData* printerData,
        const PrinterCap* printerCap)
        :
        GraphicsDriver(message, printerData, printerCap),
        fHalftone(NULL)
{
}


bool
LIPS4Driver::StartDocument()
{
        try {
                _BeginTextMode();
                _JobStart();
                _ColorModeDeclaration();
                _SoftReset();
                _SizeUnitMode();
                _SelectSizeUnit();
                _PaperFeedMode();
                _SelectPageFormat();
                _DisableAutoFF();
                _SetNumberOfCopies();
                _SidePrintingControl();
                _SetBindingMargin();
                fHalftone = new Halftone(GetJobData()->GetSurfaceType(),
                        GetJobData()->GetGamma(), GetJobData()->GetInkDensity(),
                        GetJobData()->GetDitherType());
                return true;
        }
        catch (TransportException& err) {
                return false;
        }
}


bool
LIPS4Driver::StartPage(int)
{
        try {
                fCurrentX = 0;
                fCurrentY = 0;
                _MemorizedPosition();
                return true;
        }
        catch (TransportException& err) {
                return false;
        }
}


bool
LIPS4Driver::EndPage(int)
{
        try {
                _FormFeed();
                return true;
        }
        catch (TransportException& err) {
                return false;
        }
}


bool
LIPS4Driver::EndDocument(bool)
{
        try {
                if (fHalftone)
                        delete fHalftone;

                _JobEnd();
                return true;
        }
        catch (TransportException& err) {
                return false;
        }
}


bool
LIPS4Driver::NextBand(BBitmap* bitmap, BPoint* offset)
{
        DBGMSG(("> nextBand\n"));

        try {

                if (bitmap == NULL) {
                        uchar dummy[1];
                        dummy[0] =  '\0';
                        _RasterGraphics(1, 1, 1, 0, dummy);
                        DBGMSG(("< next_band\n"));
                        return true;
                }

                BRect bounds = bitmap->Bounds();

                RECT rc;
                rc.left = (int)bounds.left;
                rc.top = (int)bounds.top;
                rc.right = (int)bounds.right;
                rc.bottom = (int)bounds.bottom;

                int height = rc.bottom - rc.top + 1;

                int x = (int)offset->x;
                int y = (int)offset->y;

                int page_height = GetPageHeight();

                if (y + height > page_height)
                        height = page_height - y;

                rc.bottom = height - 1;

                DBGMSG(("height = %d\n", height));
                DBGMSG(("x = %d\n", x));
                DBGMSG(("y = %d\n", y));

                if (get_valid_rect(bitmap, &rc)) {

                        DBGMSG(("validate rect = %d, %d, %d, %d\n",
                                rc.left, rc.top, rc.right, rc.bottom));

                        x = rc.left;
                        y += rc.top;

                        int width = rc.right - rc.left + 1;
                        int widthByte = (width + 7) / 8;
                        int height = rc.bottom - rc.top + 1;
                        int in_size = widthByte * height;
                        int out_size = (in_size * 6 + 4) / 5;
                        int delta = bitmap->BytesPerRow();

                        DBGMSG(("width = %d\n", width));
                        DBGMSG(("widthByte = %d\n", widthByte));
                        DBGMSG(("height = %d\n", height));
                        DBGMSG(("in_size = %d\n", in_size));
                        DBGMSG(("out_size = %d\n", out_size));
                        DBGMSG(("delta = %d\n", delta));
                        DBGMSG(("fHalftone_engine->Get_pixel_depth() = %d\n",
                                fHalftone->GetPixelDepth()));

                        uchar* ptr = static_cast<uchar*>(bitmap->Bits())
                                                + rc.top * delta
                                                + (rc.left * fHalftone->GetPixelDepth()) / 8;

                        int compression_method;
                        int compressed_size;
                        const uchar* buffer;

                        std::vector<uchar> in_buffer(in_size);
                        std::vector<uchar> out_buffer(out_size);

                        uchar* ptr2 = &in_buffer[0];

                        DBGMSG(("move\n"));

                        _Move(x, y);

                        for (int i = rc.top; i <= rc.bottom; i++) {
                                fHalftone->Dither(ptr2, ptr, x, y, width);
                                ptr  += delta;
                                ptr2 += widthByte;
                                y++;
                        }

                        DBGMSG(("PackBits\n"));

                        compressed_size = pack_bits(&out_buffer[0], &in_buffer[0], in_size);

                        if (compressed_size < in_size) {
                                compression_method = 11;
                                buffer = &out_buffer[0];
                        } else if (compressed_size > out_size) {
                                BAlert* alert = new BAlert("memory overrun!!!", "warning", "OK");
                                alert->SetFlags(alert->Flags() | B_CLOSE_ON_ESCAPE);
                                alert->Go();
                                return false;
                        } else {
                                compression_method = 0;
                                buffer = &in_buffer[0];
                                compressed_size = in_size;
                        }

                        DBGMSG(("compressed_size = %d\n", compressed_size));
                        DBGMSG(("widthByte = %d\n", widthByte));
                        DBGMSG(("height = %d\n", height));
                        DBGMSG(("compression_method = %d\n", compression_method));

                        _RasterGraphics(
                                compressed_size,        // size,
                                widthByte,                      // widthByte
                                height,                         // height,
                                compression_method,
                                buffer);

                } else
                        DBGMSG(("band bitmap is clean.\n"));

                if (y >= page_height) {
                        offset->x = -1.0;
                        offset->y = -1.0;
                } else
                        offset->y += height;

                DBGMSG(("< nextBand\n"));
                return true;
        }
        catch (TransportException& err) {
                BAlert* alert = new BAlert("", err.What(), "OK");
                alert->SetFlags(alert->Flags() | B_CLOSE_ON_ESCAPE);
                alert->Go();
                return false;
        }
}


void
LIPS4Driver::_BeginTextMode()
{
        WriteSpoolString("\033%%@");
}


void
LIPS4Driver::_JobStart()
{
        WriteSpoolString("\033P41;%d;1J\033\\", GetJobData()->GetXres());
}


void
LIPS4Driver::_ColorModeDeclaration()
{
//      if (color)
//              WriteSpoolString("\033[1\"p");
//      else
                WriteSpoolString("\033[0\"p");
}


void
LIPS4Driver::_SoftReset()
{
        WriteSpoolString("\033<");
}


void
LIPS4Driver::_SizeUnitMode()
{
        WriteSpoolString("\033[11h");
}


void
LIPS4Driver::_SelectSizeUnit()
{
        WriteSpoolString("\033[?7;%d I", GetJobData()->GetXres());
}


void
LIPS4Driver::_PaperFeedMode()
{
        // 0 auto
        // --------------
        // 1 MP tray
        // 2 lower
        // 3 lupper
        // --------------
        // 10 MP tray
        // 11 casette 1
        // 12 casette 2
        // 13 casette 3
        // 14 casette 4
        // 15 casette 5
        // 16 casette 6
        // 17 casette 7

        int i;

        switch (GetJobData()->GetPaperSource()) {
                case JobData::kManual:
                        i = 10;
                        break;
                case JobData::kUpper:
                        i = 11;
                        break;
                case JobData::kMiddle:
                        i = 12;
                        break;
                case JobData::kLower:
                        i = 13;
                        break;
                case JobData::kAuto:
                default:
                        i = 0;
                        break;
        }

        WriteSpoolString("\033[%dq", i);
}


void
LIPS4Driver::_SelectPageFormat()
{
        int i;

        switch (GetJobData()->GetPaper()) {
                case JobData::kA3:
                        i = 12;
                        break;

                case JobData::kA4:
                        i = 14;
                        break;

                case JobData::kA5:
                        i = 16;
                        break;

                case JobData::kJapanesePostcard:
                        i = 18;
                        break;

                case JobData::kB4:
                        i = 24;
                        break;

                case JobData::kB5:
                        i = 26;
                        break;

                case JobData::kLetter:
                        i = 30;
                        break;

                case JobData::kLegal:
                        i = 32;
                        break;

                case JobData::kExecutive:
                        i = 40;
                        break;

                case JobData::kJEnvYou4:
                        i = 50;
                        break;

                case JobData::kUser:
                        i = 90;
                        break;

                default:
                        i = 0;
                        break;
        }

        if (JobData::kLandscape == GetJobData()->GetOrientation())
                i++;

        WriteSpoolString("\033[%d;;p", i);
}


void
LIPS4Driver::_DisableAutoFF()
{
        WriteSpoolString("\033[?2h");
}


void
LIPS4Driver::_SetNumberOfCopies()
{
        WriteSpoolString("\033[%ldv", GetJobData()->GetCopies());
}


void
LIPS4Driver::_SidePrintingControl()
{
        if (GetJobData()->GetPrintStyle() == JobData::kSimplex)
                WriteSpoolString("\033[0#x");
        else
                WriteSpoolString("\033[2;0#x");
}


void
LIPS4Driver::_SetBindingMargin()
{
        if (GetJobData()->GetPrintStyle() == JobData::kDuplex) {
                int i;
//              switch (job_data()->binding_location()) {
//              case kLongEdgeLeft:
                        i = 0;
//                      break;
//              case kLongEdgeRight:
//                      i = 1;
//                      break;
//              case kShortEdgeTop:
//                      i = 2;
//                      break;
//              case kShortEdgeBottom:
//                      i = 3;
//                      break;
//              }
                WriteSpoolString("\033[%d;0#w", i);
        }
}


void
LIPS4Driver::_MemorizedPosition()
{
        WriteSpoolString("\033[0;1;0x");
}


void
LIPS4Driver::_MoveAbsoluteHorizontal(int x)
{
        WriteSpoolString("\033[%ld`", x);
}


void
LIPS4Driver::_CarriageReturn()
{
        WriteSpoolChar('\x0d');
}


void
LIPS4Driver::_MoveDown(int dy)
{
        WriteSpoolString("\033[%lde", dy);
}


void
LIPS4Driver::_RasterGraphics(int compression_size, int widthbyte, int height,
        int compression_method, const uchar* buffer)
{
// 0  RAW
// 10 RLE
// 11 packbits

        WriteSpoolString(
                "\033[%ld;%ld;%d;%ld;%ld.r",
                compression_size,
                widthbyte,
                GetJobData()->GetXres(),
                compression_method,
                height);

        WriteSpoolData(buffer, compression_size);
}


void
LIPS4Driver::_FormFeed()
{
        WriteSpoolChar('\014');
}


void
LIPS4Driver::_JobEnd()
{
        WriteSpoolString("\033P0J\033\\");
}


void
LIPS4Driver::_Move(int x, int y)
{
        if (fCurrentX != x) {
                if (x) {
                        _MoveAbsoluteHorizontal(x);
                } else {
                        _CarriageReturn();
                }
                fCurrentX = x;
        }
        if (fCurrentY != y) {
                int dy = y - fCurrentY;
                _MoveDown(dy);
                fCurrentY = y;
        }
}