//-----------------------------------------------------------------------------
// Copyright 2007 Jonathan Westhues
//
// This file is part of LDmicro.
// 
// LDmicro 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 3 of the License, or
// (at your option) any later version.
// 
// LDmicro 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 LDmicro.  If not, see <http://www.gnu.org/licenses/>.
//------
//
// The two `output devices' for the drawing code: either the export as text
// stuff to write to a file, or all the routines concerned with drawing to
// the screen.
// Jonathan Westhues, Dec 2004
// 
// Ported to linus by: R Ramana, 2018
//-----------------------------------------------------------------------------

#include "linuxUI.h"
#include <stdio.h>
#include <stdlib.h>

#include "ldmicro.h"

void (*DrawChars)(int, int, char *);
GtkSettings *SettingsInstance;

// After an undo all the memory addresses change but make an effort to put
// the cursor roughly where it should be.
int SelectedGxAfterNextPaint = -1;
int SelectedGyAfterNextPaint = -1;

// After pushing a rung up or down the position of that rung in the table
// changes, but the cursor should stay where it was.
BOOL ScrollSelectedIntoViewAfterNextPaint;

// Buffer that we write to when exporting (drawing) diagram to a text file. 
// Dynamically allocated so that we're at least slightly efficient.
static char **ExportBuffer;

// The fonts that we will use to draw the ladder diagram: fixed width, one
// normal-weight, one bold.
HFONT       FixedWidthFont;
HFONT       FixedWidthFontBold;

// Different colour brushes for right and left buses in simulation, but same
// colour for both in edit mode; also for the backgrounds in simulation and
// edit modes.
static HBRUSH   BusRightBus;
static HBRUSH   BusLeftBrush;
static HBRUSH   BusBrush;
static HBRUSH   BgBrush;
static HBRUSH   SimBgBrush;

// Parameters that determine our offset if we are scrolled
int ScrollXOffset;
int ScrollYOffset;
int ScrollXOffsetMax;
int ScrollYOffsetMax;

// Is the cursor currently drawn? We XOR it so this gets toggled.
static BOOL CursorDrawn;

// Colours with which to do syntax highlighting, configurable
SyntaxHighlightingColours HighlightColours;

#define X_RIGHT_PADDING 30

//-----------------------------------------------------------------------------
// Blink the cursor on the schematic; called by a Windows timer. We XOR
// draw it so just draw the same rectangle every time to show/erase the
// cursor. Cursor may be in one of four places in the selected leaf (top,
// bottom, left, right) but we don't care; just go from the coordinates
// computed when we drew the schematic in the paint procedure.
//-----------------------------------------------------------------------------
void CALLBACK BlinkCursor(HWND hwnd, UINT msg, UINT_PTR id, DWORD time)
{
    // if(!isFocus(MainWindow) && !CursorDrawn) return;
    // if(Cursor.left == 0) return;

    // PlcCursor c;
    // SettingsInstance = gtk_settings_get_default();
    // gtk_settings_install_property_parser (gtk-cursor-blink ,black);

}

//-----------------------------------------------------------------------------
// Output a string to the screen at a particular location, in character-
// sized units.
//-----------------------------------------------------------------------------
static void DrawCharsToScreen(int cx, int cy, char *str)
{
    // cy -= ScrollYOffset*POS_HEIGHT;
    // if(cy < -2) return;
    // if(cy*FONT_HEIGHT + Y_PADDING > IoListTop) return;

    // COLORREF prev;
    // BOOL firstTime = TRUE;
    // BOOL inNumber = FALSE;
    // BOOL inComment = FALSE;
    // int inBrace = 0;
    // for(; *str; str++, cx++) {
    //     int x = cx*FONT_WIDTH + X_PADDING;
    //     int y = cy*FONT_HEIGHT + Y_PADDING;

    //     BOOL hiOk = !(InSimulationMode || ThisHighlighted);

    //     if(strchr("{}[]", *str) && hiOk && !inComment)  {
    //         if(*str == '{' || *str == '[') inBrace++;
    //         if(inBrace == 1) {
    //             prev = GetTextColor(Hdc);
    //             SetTextColor(Hdc, HighlightColours.punct);
    //             TextOut(Hdc, x, y, str, 1);
    //             SetTextColor(Hdc, prev);
    //         } else {
    //             TextOut(Hdc, x, y, str, 1);
    //         }
    //         if(*str == ']' || *str == '}') inBrace--;
    //     } else if((
    //         (isdigit(*str) && (firstTime || isspace(str[-1]) 
    //             || str[-1] == ':' || str[-1] == '[')) ||
    //         (*str == '-' && isdigit(str[1]))) && hiOk && !inComment)
    //     {
    //         prev = GetTextColor(Hdc);
    //         SetTextColor(Hdc, HighlightColours.lit);
    //         TextOut(Hdc, x, y, str, 1);
    //         SetTextColor(Hdc, prev);
    //         inNumber = TRUE;
    //     } else if(*str == '\x01') {
    //         cx--;
    //         if(hiOk) {
    //             prev = GetTextColor(Hdc);
    //             SetTextColor(Hdc, HighlightColours.op);
    //         }
    //     } else if(*str == '\x02') {
    //         cx--;
    //         if(hiOk) {
    //             SetTextColor(Hdc, prev);
    //             inComment = FALSE;
    //         }
    //     } else if(*str == '\x03') {
    //         cx--;
    //         if(hiOk) {
    //             prev = GetTextColor(Hdc);
    //             SetTextColor(Hdc, HighlightColours.comment);
    //             inComment = TRUE;
    //         }
    //     } else if(inNumber) {
    //         if(isdigit(*str) || *str == '.') {
    //             prev = GetTextColor(Hdc);
    //             SetTextColor(Hdc, HighlightColours.lit);
    //             TextOut(Hdc, x, y, str, 1);
    //             SetTextColor(Hdc, prev);
    //         } else {
    //             TextOut(Hdc, x, y, str, 1);
    //             inNumber = FALSE;
    //         }
    //     } else {
    //         TextOut(Hdc, x, y, str, 1);
    //     }

    //     firstTime = FALSE;
    // }
}

//-----------------------------------------------------------------------------
// Total number of columns that we can display in the given amount of 
// window area. Need to leave some slop on the right for the scrollbar, of
// course.
//-----------------------------------------------------------------------------
int ScreenColsAvailable(void)
{
    // RECT r;
    // GetClientRect(MainWindow, &r);

    // return (r.right - (X_PADDING + X_RIGHT_PADDING)) / (POS_WIDTH*FONT_WIDTH);
}

//-----------------------------------------------------------------------------
// Total number of columns that we can display in the given amount of 
// window area. Need to leave some slop on the right for the scrollbar, of
// course, and extra slop at the bottom for the horiz scrollbar if it is
// shown.
//-----------------------------------------------------------------------------
int ScreenRowsAvailable(void)
{
    // int adj;
    // if(ScrollXOffsetMax == 0) {
    //     adj = 0;
    // } else {
    //     adj = 18;
    // }
    // return (IoListTop - Y_PADDING - adj) / (POS_HEIGHT*FONT_HEIGHT);
}

//-----------------------------------------------------------------------------
// Paint the ladder logic program to the screen. Also figure out where the
// cursor should go and fill in coordinates for BlinkCursor. Not allowed to
// draw deeper than IoListTop, as we would run in to the I/O listbox.
//-----------------------------------------------------------------------------
void PaintWindow(void)
{
    // static HBITMAP BackBitmap;
    // static HDC BackDc;
    // static int BitmapWidth;

    // ok();

    // RECT r;
    // GetClientRect(MainWindow, &r);
    // int bw = r.right;
    // int bh = IoListTop;

    // HDC paintDc;
    // if(!BackDc) {
    //     HWND desktop = GetDesktopWindow();
    //     RECT dk;
    //     GetClientRect(desktop, &dk);

    //     BitmapWidth = max(2000, dk.right + 300);
    //     BackBitmap = CreateCompatibleBitmap(Hdc, BitmapWidth, dk.bottom + 300);
    //     BackDc = CreateCompatibleDC(Hdc);
    //     SelectObject(BackDc, BackBitmap);
    // }
    // paintDc = Hdc;
    // Hdc = BackDc;

    // RECT fi;
    // fi.left = 0; fi.top = 0;
    // fi.right = BitmapWidth; fi.bottom = bh;
    // FillRect(Hdc, &fi, InSimulationMode ? SimBgBrush : BgBrush);
    
    // // now figure out how we should draw the ladder logic
    // ColsAvailable = ProgCountWidestRow();
    // if(ColsAvailable < ScreenColsAvailable()) {
    //     ColsAvailable = ScreenColsAvailable();
    // }
    // memset(DisplayMatrix, 0, sizeof(DisplayMatrix));
    // SelectionActive = FALSE;
    // memset(&Cursor, 0, sizeof(Cursor));

    // DrawChars = DrawCharsToScreen;

    // int i;
    // int cy = 0;
    // int rowsAvailable = ScreenRowsAvailable();
    // for(i = 0; i < Prog.numRungs; i++) {
    //     int thisHeight = POS_HEIGHT*CountHeightOfElement(ELEM_SERIES_SUBCKT,
    //         Prog.rungs[i]);

    //     // For speed, there is no need to draw everything all the time, but
    //     // we still must draw a bit above and below so that the DisplayMatrix
    //     // is filled in enough to make it possible to reselect using the
    //     // cursor keys.
    //     if(((cy + thisHeight) >= (ScrollYOffset - 8)*POS_HEIGHT) &&
    //         (cy < (ScrollYOffset + rowsAvailable + 8)*POS_HEIGHT))
    //     {
    //         SetBkColor(Hdc, InSimulationMode ? HighlightColours.simBg :
    //             HighlightColours.bg);
    //         SetTextColor(Hdc, InSimulationMode ? HighlightColours.simRungNum :
    //             HighlightColours.rungNum);
    //         SelectObject(Hdc, FixedWidthFont);
    //         int rung = i + 1;
    //         int y = Y_PADDING + FONT_HEIGHT*cy;
    //         int yp = y + FONT_HEIGHT*(POS_HEIGHT/2) - 
    //             POS_HEIGHT*FONT_HEIGHT*ScrollYOffset;

    //         if(rung < 10) {
    //             char r[1] = { rung + '0' };
    //             TextOut(Hdc, 8 + FONT_WIDTH, yp, r, 1);
    //         } else {
    //             char r[2] = { (rung / 10) + '0', (rung % 10) + '0' };
    //             TextOut(Hdc, 8, yp, r, 2);
    //         }

    //         int cx = 0;
    //         DrawElement(ELEM_SERIES_SUBCKT, Prog.rungs[i], &cx, &cy, 
    //             Prog.rungPowered[i]);
    //     }

    //     cy += thisHeight;
    //     cy += POS_HEIGHT;
    // }
    // cy -= 2;
    // DrawEndRung(0, cy);

    // if(SelectedGxAfterNextPaint >= 0) {
    //     MoveCursorNear(SelectedGxAfterNextPaint, SelectedGyAfterNextPaint);
    //     InvalidateRect(MainWindow, NULL, FALSE);
    //     SelectedGxAfterNextPaint = -1;
    //     SelectedGyAfterNextPaint = -1;
    // } else if(ScrollSelectedIntoViewAfterNextPaint && Selected) {
    //     SelectElement(-1, -1, Selected->selectedState);
    //     ScrollSelectedIntoViewAfterNextPaint = FALSE;
    //     InvalidateRect(MainWindow, NULL, FALSE);
    // } else {
    //     if(!SelectionActive) {
    //         if(Prog.numRungs > 0) {
    //             if(MoveCursorTopLeft()) {
    //                 InvalidateRect(MainWindow, NULL, FALSE);
    //             }
    //         }
    //     }
    // }

    // // draw the `buses' at either side of the screen
    // r.left = X_PADDING - FONT_WIDTH;
    // r.top = 0;
    // r.right = r.left + 4;
    // r.bottom = IoListTop;
    // FillRect(Hdc, &r, InSimulationMode ? BusLeftBrush : BusBrush);

    // r.left += POS_WIDTH*FONT_WIDTH*ColsAvailable + 2;
    // r.right += POS_WIDTH*FONT_WIDTH*ColsAvailable + 2;
    // FillRect(Hdc, &r, InSimulationMode ? BusRightBus : BusBrush);
 
    // CursorDrawn = FALSE;

    // BitBlt(paintDc, 0, 0, bw, bh, BackDc, ScrollXOffset, 0, SRCCOPY);

    // if(InSimulationMode) {
    //     KillTimer(MainWindow, TIMER_BLINK_CURSOR);
    // } else {
    //     KillTimer(MainWindow, TIMER_BLINK_CURSOR);
    //     BlinkCursor(NULL, 0, NULL, 0);
    //     SetTimer(MainWindow, TIMER_BLINK_CURSOR, 800, BlinkCursor);
    // }

    // Hdc = paintDc;
    // ok();
}

//-----------------------------------------------------------------------------
// Set up the syntax highlighting colours, according to the currently selected
// scheme.
//-----------------------------------------------------------------------------
static void SetSyntaxHighlightingColours(void)
{
    static const SyntaxHighlightingColours Schemes[] = {
        {
            RGB(0, 0, 0),           // bg
            RGB(255, 255, 225),     // def
            RGB(255, 110, 90),      // selected
            RGB(255, 150, 90),      // op
            RGB(255, 255, 100),     // punct
            RGB(255, 160, 160),     // lit
            RGB(120, 255, 130),     // name
            RGB(130, 130, 130),     // rungNum
            RGB(130, 130, 245),     // comment

            RGB(255, 255, 255),     // bus

            RGB(0, 0, 0),           // simBg
            RGB(130, 130, 130),     // simRungNum
            RGB(100, 130, 130),     // simOff
            RGB(255, 150, 150),     // simOn

            RGB(255, 150, 150),     // simBusLeft
            RGB(150, 150, 255),     // simBusRight
        },
    };

    memcpy(&HighlightColours, &Schemes[0], sizeof(Schemes[0]));
}

//-----------------------------------------------------------------------------
// Set up the stuff we'll need to draw our schematic diagram. Fonts, brushes,
// pens, etc.
//-----------------------------------------------------------------------------
void InitForDrawing(void)
{
    // SetSyntaxHighlightingColours();

    // FixedWidthFont = CreateFont(
    //     FONT_HEIGHT, FONT_WIDTH,
    //     0, 0,
    //     FW_REGULAR,
    //     FALSE,
    //     FALSE,
    //     FALSE,
    //     ANSI_CHARSET,
    //     OUT_DEFAULT_PRECIS,
    //     CLIP_DEFAULT_PRECIS,
    //     DEFAULT_QUALITY,
    //     FF_DONTCARE,
    //     "Lucida Console");

    // FixedWidthFontBold = CreateFont(
    //     FONT_HEIGHT, FONT_WIDTH,
    //     0, 0,
    //     FW_REGULAR, // the bold text renders funny under Vista
    //     FALSE,
    //     FALSE,
    //     FALSE,
    //     ANSI_CHARSET,
    //     OUT_DEFAULT_PRECIS,
    //     CLIP_DEFAULT_PRECIS,
    //     DEFAULT_QUALITY,
    //     FF_DONTCARE,
    //     "Lucida Console");

    // LOGBRUSH lb;
    // lb.lbStyle = BS_SOLID;
    // lb.lbColor = HighlightColours.simBusRight;
    // BusRightBus = CreateBrushIndirect(&lb);

    // lb.lbColor = HighlightColours.simBusLeft;
    // BusLeftBrush = CreateBrushIndirect(&lb);

    // lb.lbColor = HighlightColours.bus;
    // BusBrush = CreateBrushIndirect(&lb);

    // lb.lbColor = HighlightColours.bg;
    // BgBrush = CreateBrushIndirect(&lb);

    // lb.lbColor = HighlightColours.simBg;
    // SimBgBrush = CreateBrushIndirect(&lb);
}

//-----------------------------------------------------------------------------
// DrawChars function, for drawing to the export buffer instead of to the
// screen.
//-----------------------------------------------------------------------------
static void DrawCharsToExportBuffer(int cx, int cy, char *str)
{
    while(*str) {
        if(*str >= 10) {
            ExportBuffer[cy][cx] = *str;
            cx++;
        }
        str++;
    }
}

//-----------------------------------------------------------------------------
// Export a text drawing of the ladder logic program to a file.
//-----------------------------------------------------------------------------
void ExportDrawingAsText(char *file)
{
    // int maxWidth = ProgCountWidestRow();
    // ColsAvailable = maxWidth;

    // int totalHeight = 0;
    // int i;
    // for(i = 0; i < Prog.numRungs; i++) {
    //     totalHeight += CountHeightOfElement(ELEM_SERIES_SUBCKT, Prog.rungs[i]);
    //     totalHeight += 1;
    // }
    // totalHeight *= POS_HEIGHT;
    // totalHeight += 3;

    // ExportBuffer = (char **)CheckMalloc(totalHeight * sizeof(char *));
   
    // int l = maxWidth*POS_WIDTH + 8;
    // for(i = 0; i < totalHeight; i++) {
    //     ExportBuffer[i] = (char *)CheckMalloc(l);
    //     memset(ExportBuffer[i], ' ', l-1);
    //     ExportBuffer[i][4] = '|';
    //     ExportBuffer[i][3] = '|';
    //     ExportBuffer[i][l-3] = '|';
    //     ExportBuffer[i][l-2] = '|';
    //     ExportBuffer[i][l-1] = '\0';
    // }

    // DrawChars = DrawCharsToExportBuffer;

    // int cy = 1;
    // for(i = 0; i < Prog.numRungs; i++) {
    //     int cx = 5;
    //     DrawElement(ELEM_SERIES_SUBCKT, Prog.rungs[i], &cx, &cy, 
    //         Prog.rungPowered[i]);

    //     if((i + 1) < 10) {
    //         ExportBuffer[cy+1][1] = '0' + (i + 1);
    //     } else {
    //         ExportBuffer[cy+1][1] = '0' + ((i + 1) % 10);
    //         ExportBuffer[cy+1][0] = '0' + ((i + 1) / 10);
    //     }

    //     cy += POS_HEIGHT*CountHeightOfElement(ELEM_SERIES_SUBCKT,
    //         Prog.rungs[i]);
    //     cy += POS_HEIGHT;
    // }
    // cy -= 2;
    // DrawEndRung(5, cy);

    // FILE *f = fopen(file, "w");
    // if(!f) {
    //     Error(_("Couldn't open '%s'\n"), f);
    //     return;
    // }

    // fprintf(f, "LDmicro export text\n");

    // if(Prog.mcu) {
    //     fprintf(f, "for '%s', %.6f MHz crystal, %.1f ms cycle time\n\n",
    //         Prog.mcu->mcuName, Prog.mcuClock/1e6, Prog.cycleTime/1e3);
    // } else {
    //     fprintf(f, "no MCU assigned, %.6f MHz crystal, %.1f ms cycle time\n\n",
    //         Prog.mcuClock/1e6, Prog.cycleTime/1e3);
    // }

    // fprintf(f, "\nLADDER DIAGRAM:\n\n");

    // for(i = 0; i < totalHeight; i++) {
    //     ExportBuffer[i][4] = '|';
    //     fprintf(f, "%s\n", ExportBuffer[i]);
    //     CheckFree(ExportBuffer[i]);
    // }
    // CheckFree(ExportBuffer);
    // ExportBuffer = NULL;

    // fprintf(f, _("\n\nI/O ASSIGNMENT:\n\n"));
    
    // fprintf(f, _("  Name                       | Type               | Pin\n"));
    // fprintf(f,   " ----------------------------+--------------------+------\n");
    // for(i = 0; i < Prog.io.count; i++) {
    //     char b[1024];
    //     memset(b, '\0', sizeof(b));

    //     PlcProgramSingleIo *io = &Prog.io.assignment[i];
    //     char *type = IoTypeToString(io->type);
    //     char pin[MAX_NAME_LEN];

    //     PinNumberForIo(pin, io);

    //     sprintf(b, "                             |                    | %s\n",
    //         pin);

    //     memcpy(b+2, io->name, strlen(io->name));
    //     memcpy(b+31, type, strlen(type));
    //     fprintf(f, "%s", b);
    // }

    // fclose(f);

    // // we may have trashed the grid tables a bit; a repaint will fix that
    // InvalidateRect(MainWindow, NULL, FALSE);
}

//-----------------------------------------------------------------------------
// Determine the settings of the vertical and (if needed) horizontal
// scrollbars used to scroll our view of the program.
//-----------------------------------------------------------------------------
void SetUpScrollbars(BOOL *horizShown, SCROLLINFO *horiz, SCROLLINFO *vert)
{
    // int totalHeight = 0;
    // int i;
    // for(i = 0; i < Prog.numRungs; i++) {
    //     totalHeight += CountHeightOfElement(ELEM_SERIES_SUBCKT, Prog.rungs[i]);
    //     totalHeight++;
    // }
    // totalHeight += 1; // for the end rung

    // int totalWidth = ProgCountWidestRow();

    // if(totalWidth <= ScreenColsAvailable()) {
    //     *horizShown = FALSE;
    //     ScrollXOffset = 0;
    //     ScrollXOffsetMax = 0;
    // } else {
    //     *horizShown = TRUE;
    //     memset(horiz, 0, sizeof(*horiz));
    //     horiz->cbSize = sizeof(*horiz);
    //     horiz->fMask = SIF_DISABLENOSCROLL | SIF_ALL;
    //     horiz->nMin = 0;
    //     horiz->nMax = X_PADDING + totalWidth*POS_WIDTH*FONT_WIDTH;
    //     RECT r;
    //     GetClientRect(MainWindow, &r);
    //     horiz->nPage = r.right - X_PADDING;
    //     horiz->nPos = ScrollXOffset;

    //     ScrollXOffsetMax = horiz->nMax - horiz->nPage + 1;
    //     if(ScrollXOffset > ScrollXOffsetMax) ScrollXOffset = ScrollXOffsetMax;
    //     if(ScrollXOffset < 0) ScrollXOffset = 0;
    // }

    // vert->cbSize = sizeof(*vert);
    // vert->fMask = SIF_DISABLENOSCROLL | SIF_ALL;
    // vert->nMin = 0;
    // vert->nMax = totalHeight - 1;
    // vert->nPos = ScrollYOffset;
    // vert->nPage = ScreenRowsAvailable();

    // ScrollYOffsetMax = vert->nMax - vert->nPage + 1;

    // if(ScrollYOffset > ScrollYOffsetMax) ScrollYOffset = ScrollYOffsetMax;
    // if(ScrollYOffset < 0) ScrollYOffset = 0;
}