/**
 * Functions to draw and plot text on screen
 * @file drawtxt.cpp
 */
#include "fctsys.h"
#include "gr_basic.h"

#include "common.h"
#include "plot_common.h"

#include "trigo.h"
#include "macros.h"
#include "class_drawpanel.h"
#include "class_base_screen.h"

#ifndef DEFAULT_SIZE_TEXT
#   define DEFAULT_SIZE_TEXT 50
#endif

#define EDA_DRAWBASE
#include "newstroke_font.h"
#include "plot_common.h"

/* factor used to calculate actual size of shapes from hershey fonts (could be adjusted depending on the font name)
 * Its value is choosen in order to have letters like M, P .. vertical size equal to the vertical char size parameter
 * Of course some shapes can be bigger or smaller than the vertical char size parameter
 */
#define HERSHEY_SCALE_FACTOR 1 / 21.0
double s_HerscheyScaleFactor = HERSHEY_SCALE_FACTOR;


/**
 * Function GetPensizeForBold
 * @return the "best" value for a pen size to draw/plot a bold text
 * @param aTextSize = the char size (height or width)
 */
int GetPenSizeForBold( int aTextSize )
{
    return wxRound( aTextSize / 5.0 );
}


/**
 * Function  Clamp_Text_PenSize
 *As a rule, pen width should not be >1/4em, otherwise the character
 * will be cluttered up in its own fatness
 * so pen width max is aSize/4 for bold text, and aSize/6 for normal text
 * The "best" pen width is aSize/5 for bold texts,
 * so the clamp is consistant with bold option.
 * @param aPenSize = the pen size to clamp
 * @param aSize the char size (height or width)
 * @param aBold = true if text accept bold pen size
 * @return the max pen size allowed
 */
int Clamp_Text_PenSize( int aPenSize, int aSize, bool aBold )
{
    int    penSize  = aPenSize;
    double scale    = aBold ? 4.0 : 6.0;
    int    maxWidth = wxRound( ABS( aSize ) / scale );

    if( penSize > maxWidth )
        penSize = maxWidth;
    return penSize;
}


int Clamp_Text_PenSize( int aPenSize, wxSize aSize, bool aBold )
{
    int size = MIN( ABS( aSize.x ), ABS( aSize.y ) );

    return Clamp_Text_PenSize( aPenSize, size, aBold );
}


/* Functions to draw / plot a string.
 *  texts have only one line.
 *  They can be in italic.
 *  Horizontal and Vertical justification are handled.
 *  Texts can be rotated
 *  substrings between ~ markers can be "negated" (i.e. with an over bar
 */

/**
 * Function NegableTextLength
 * Return the text length of a negable string, excluding the ~ markers */
int NegableTextLength( const wxString& aText )
{
    int char_count = aText.length();

    /* Fix the character count, removing the ~ found */
    for( int i = char_count - 1; i >= 0; i-- )
    {
        if( aText[i] == '~' )
        {
            char_count--;
        }
    }

    return char_count;
}


/* Function GetHersheyShapeDescription
 * return a pointer to the shape corresponding to unicode value AsciiCode
 * Note we use the same font for Bold and Normal texts
 * because kicad handles a variable pen size to do that
 * that gives better results in XOR draw mode.
 */
static const char* GetHersheyShapeDescription( int AsciiCode )
{
    /* calculate font length */
    int font_length_max = newstroke_font_bufsize;

    if( AsciiCode >= (32 + font_length_max) )
        AsciiCode = '?';
    if( AsciiCode < 32 )
        AsciiCode = 32;                 /* Clamp control chars */
    AsciiCode -= 32;

    return newstroke_font[AsciiCode];
}


int ReturnGraphicTextWidth( const wxString& aText, int aXSize, bool aItalic, bool aWidth )
{
    int tally = 0;
    int char_count = aText.length();

    for( int i = 0; i < char_count; i++ )
    {
        int AsciiCode = aText[i];

        if( AsciiCode == '~' ) /* Skip the negation marks */
        {
            continue;
        }

        const char* ptcar = GetHersheyShapeDescription( AsciiCode );
        /* Get metrics */
        int         xsta = *ptcar++ - 'R';
        int         xsto = *ptcar++ - 'R';
        tally += wxRound( aXSize * (xsto - xsta) * s_HerscheyScaleFactor );
    }

    /* Italic correction, 1/8em */
    if( aItalic )
    {
        tally += wxRound( aXSize * 0.125 );
    }
    return tally;
}


/* Helper function for drawing character polygons */
static void DrawGraphicTextPline(
    EDA_RECT* aClipBox,
    wxDC* aDC,
    EDA_Colors aColor,
    int aWidth,
    bool aSketchMode,
    int point_count,
    wxPoint* coord,
    void (* aCallback)(int x0, int y0, int xf, int yf ),
    PLOTTER* aPlotter )
{
    if( aPlotter )
    {
        aPlotter->move_to( coord[0] );
        for( int ik = 1; ik < point_count; ik++ )
        {
            aPlotter->line_to( coord[ik] );
        }

        aPlotter->pen_finish();
    }
    else if( aCallback )
    {
        for( int ik = 0; ik < (point_count - 1); ik++ )
        {
            aCallback( coord[ik].x, coord[ik].y,
                       coord[ik + 1].x, coord[ik + 1].y );
        }
    }
    else if( aSketchMode )
    {
        for( int ik = 0; ik < (point_count - 1); ik++ )
            GRCSegm( aClipBox, aDC, coord[ik].x, coord[ik].y,
                     coord[ik + 1].x, coord[ik + 1].y, aWidth, aColor );
    }
    else
        GRPoly( aClipBox, aDC, point_count, coord, 0,
                aWidth, aColor, aColor );
}


/* Helper function for texts with over bar
 */
static int overbar_position( int size_v, int thickness )
{
    return wxRound( ( (double) size_v * 26 * s_HerscheyScaleFactor ) + ( (double) thickness * 1.5 ) );
}


/**
 * Function DrawGraphicText
 * Draw a graphic text (like module texts)
 *  @param aPanel = the current DrawPanel. NULL if draw within a 3D GL Canvas
 *  @param aDC = the current Device Context. NULL if draw within a 3D GL Canvas
 *  @param aPos = text position (according to h_justify, v_justify)
 *  @param aColor (enum EDA_Colors) = text color
 *  @param aText = text to draw
 *  @param aOrient = angle in 0.1 degree
 *  @param aSize = text size (size.x or size.y can be < 0 for mirrored texts)
 *  @param aH_justify = horizontal justification (Left, center, right)
 *  @param aV_justify = vertical justification (bottom, center, top)
 *  @param aWidth = line width (pen width) (use default width if aWidth = 0)
 *      if width < 0 : draw segments in sketch mode, width = abs(width)
 *      Use a value min(aSize.x, aSize.y) / 5 for a bold text
 *  @param aItalic = true to simulate an italic font
 *  @param aBold = true to use a bold font. Useful only with default width value (aWidth = 0)
 *  @param aCallback() = function called (if non null) to draw each segment.
 *                  used to draw 3D texts or for plotting, NULL for normal drawings
 *  @param aPlotter = a pointer to a PLOTTER instance, when this function is used to plot
 *                  the text. NULL to draw this text.
 */
void DrawGraphicText( EDA_DRAW_PANEL* aPanel,
                      wxDC* aDC,
                      const wxPoint& aPos,
                      EDA_Colors aColor,
                      const wxString& aText,
                      int aOrient,
                      const wxSize& aSize,
                      enum GRTextHorizJustifyType aH_justify,
                      enum GRTextVertJustifyType aV_justify,
                      int aWidth,
                      bool aItalic,
                      bool aBold,
                      void (* aCallback)( int x0, int y0, int xf, int yf ),
                      PLOTTER* aPlotter )
{
    int       AsciiCode;
    int       x0, y0;
    int       size_h, size_v;
    unsigned  ptr;
    int       dx, dy;                       // Draw coordinate for segments to draw. also used in some other calculation
    wxPoint   current_char_pos;             // Draw coordinates for the current char
    wxPoint   overbar_pos;                  // Start point for the current overbar
    int       overbars;                     // Number of ~ seen
    int       overbar_italic_comp;          // Italic compensation for overbar
    EDA_RECT* clipBox;                      // Clip box used in basic draw functions

    clipBox = aPanel ? &aPanel->m_ClipBox : NULL;
    #define        BUF_SIZE 100
    wxPoint coord[BUF_SIZE + 1];                // Buffer coordinate used to draw polylines (one char shape)
    bool    sketch_mode    = false;
    bool    italic_reverse = false;             // true for mirrored texts with m_Size.x < 0

    size_h = aSize.x;                           /* PLEASE NOTE: H is for HORIZONTAL not for HEIGHT */
    size_v = aSize.y;

    if( aWidth == 0 && aBold )       // Use default values if aWidth == 0
        aWidth = GetPenSizeForBold( MIN( aSize.x, aSize.y ) );

    if( aWidth < 0 )
    {
        aWidth = -aWidth;
        sketch_mode = true;
    }

#ifdef CLIP_PEN      // made by draw and plot functions
    aWidth = Clamp_Text_PenSize( aWidth, aSize, aBold );
#endif

    if( size_h < 0 )       // text is mirrored using size.x < 0 (mirror / Y axis)
        italic_reverse = true;

    unsigned char_count = NegableTextLength( aText );
    if( char_count == 0 )
        return;

    current_char_pos = aPos;

    dx = ReturnGraphicTextWidth( aText, size_h, aItalic, aWidth );
    dy = size_v;

    /* Do not draw the text if out of draw area! */
    if( aPanel )
    {
        int xm, ym, ll, xc, yc;
        ll = ABS( dx );

        xc = current_char_pos.x;
        yc = current_char_pos.y;

        x0 = aPanel->m_ClipBox.GetX() - ll;
        y0 = aPanel->m_ClipBox.GetY() - ll;
        xm = aPanel->m_ClipBox.GetRight() + ll;
        ym = aPanel->m_ClipBox.GetBottom() + ll;

        if( xc < x0 )
            return;
        if( yc < y0 )
            return;
        if( xc > xm )
            return;
        if( yc > ym )
            return;
    }


    /* Compute the position of the first letter of the text
     * this position is the position of the left bottom point of the letter
     * this is the same as the text position only for a left and bottom justified text
     * In others cases, this position must be calculated from the text position ans size
     */

    switch( aH_justify )
    {
    case GR_TEXT_HJUSTIFY_CENTER:
        current_char_pos.x -= dx / 2;
        break;

    case GR_TEXT_HJUSTIFY_RIGHT:
        current_char_pos.x -= dx;
        break;

    case GR_TEXT_HJUSTIFY_LEFT:
        break;
    }

    switch( aV_justify )
    {
    case GR_TEXT_VJUSTIFY_CENTER:
        current_char_pos.y += dy / 2;
        break;

    case GR_TEXT_VJUSTIFY_TOP:
        current_char_pos.y += dy;
        break;

    case GR_TEXT_VJUSTIFY_BOTTOM:
        break;
    }

    // Note: if aPanel == NULL, we are using a GL Canvas that handle scaling
    if( aSize.x == 0 )
        return;

    /* if a text size is too small, the text cannot be drawn, and it is drawn as a single
     * graphic line */
    if( ABS( aSize.x ) < 3 )
    {
        /* draw the text as a line always vertically centered */
        wxPoint end( current_char_pos.x + dx, current_char_pos.y );

        RotatePoint( &current_char_pos, aPos, aOrient );
        RotatePoint( &end, aPos, aOrient );

        if( aPlotter )
        {
            aPlotter->move_to( current_char_pos );
            aPlotter->finish_to( end );
        }
        else if( aCallback )
        {
            aCallback( current_char_pos.x, current_char_pos.y, end.x, end.y );
        }
        else
            GRLine( &aPanel->m_ClipBox, aDC,
                    current_char_pos.x, current_char_pos.y, end.x, end.y, aWidth, aColor );

        return;
    }

    if( aItalic )
    {
        overbar_italic_comp = overbar_position( size_v, aWidth ) / 8;
        if( italic_reverse )
        {
            overbar_italic_comp = -overbar_italic_comp;
        }
    }
    else
    {
        overbar_italic_comp = 0;
    };

    overbars = 0;
    ptr = 0;   /* ptr = text index */
    while( ptr < char_count )
    {
        if( aText[ptr + overbars] == '~' )
        {
            /* Found an overbar, adjust the pointers */
            overbars++;

            if( overbars % 2 )
            {
                /* Starting the overbar */
                overbar_pos    = current_char_pos;
                overbar_pos.x += overbar_italic_comp;
                overbar_pos.y -= overbar_position( size_v, aWidth );
                RotatePoint( &overbar_pos, aPos, aOrient );
            }
            else
            {
                /* Ending the overbar */
                coord[0]       = overbar_pos;
                overbar_pos    = current_char_pos;
                overbar_pos.x += overbar_italic_comp;
                overbar_pos.y -= overbar_position( size_v, aWidth );
                RotatePoint( &overbar_pos, aPos, aOrient );
                coord[1] = overbar_pos;
                /* Plot the overbar segment */
                DrawGraphicTextPline( clipBox, aDC, aColor, aWidth,
                                      sketch_mode, 2, coord, aCallback, aPlotter );
            }
            continue; /* Skip ~ processing */
        }

        AsciiCode = aText.GetChar( ptr + overbars );

        const char* ptcar = GetHersheyShapeDescription( AsciiCode );
        /* Get metrics */
        int         xsta = *ptcar++ - 'R';
        int         xsto = *ptcar++ - 'R';
        int         point_count = 0;
        bool        endcar = false;
        while( !endcar )
        {
            int hc1, hc2;
            hc1 = *ptcar++;
            if( hc1 )
            {
                hc2 = *ptcar++;
            }
            else
            {
                // End of character, insert a synthetic pen up:
                hc1    = ' ';
                hc2    = 'R';
                endcar = true;
            }
            // Do the Hershey decode thing: coordinates values are coded as <value> + 'R'
            hc1 -= 'R'; hc2 -= 'R';

            /* Pen up request */
            if( hc1 == -50 && hc2 == 0 )
            {
                if( point_count )
                {
                    if( aWidth <= 1 )
                        aWidth = 0;
                    DrawGraphicTextPline( clipBox, aDC, aColor, aWidth,
                                          sketch_mode, point_count, coord,
                                          aCallback, aPlotter );
                }
                point_count = 0;
            }
            else
            {
                wxPoint currpoint;
                hc1 -= xsta; hc2 -= 11; /* Align the midpoint */
                hc1  = wxRound( hc1 * size_h * s_HerscheyScaleFactor );
                hc2  = wxRound( hc2 * size_v * s_HerscheyScaleFactor );

                // To simulate an italic font, add a x offset depending on the y offset
                if( aItalic )
                    hc1 -= wxRound( italic_reverse ? -hc2 / 8.0 : hc2 / 8.0 );
                currpoint.x = hc1 + current_char_pos.x;
                currpoint.y = hc2 + current_char_pos.y;

                RotatePoint( &currpoint, aPos, aOrient );
                coord[point_count] = currpoint;
                if( point_count < BUF_SIZE - 1 )
                    point_count++;
            }
        }

        /* end draw 1 char */

        ptr++;

        // Apply the advance width
        current_char_pos.x += wxRound( size_h * (xsto - xsta) * s_HerscheyScaleFactor );
    }

    if( overbars % 2 )
    {
        /* Close the last overbar */
        coord[0]       = overbar_pos;
        overbar_pos    = current_char_pos;
        overbar_pos.y -= overbar_position( size_v, aWidth );
        RotatePoint( &overbar_pos, aPos, aOrient );
        coord[1] = overbar_pos;
        /* Plot the overbar segment */
        DrawGraphicTextPline( clipBox, aDC, aColor, aWidth,
                              sketch_mode, 2, coord, aCallback, aPlotter );
    }
}


/**
 * Function PlotGraphicText
 *  same as DrawGraphicText, but plot graphic text insteed of draw it
 *  @param aPos = text position (according to aH_justify, aV_justify)
 *  @param aColor (enum EDA_Colors) = text color
 *  @param aText = text to draw
 *  @param aOrient = angle in 0.1 degree
 *  @param aSize = text size (size.x or size.y can be < 0 for mirrored texts)
 *  @param aH_justify = horizontal justification (Left, center, right)
 *  @param aV_justify = vertical justification (bottom, center, top)
 *  @param aWidth = line width (pen width) (default = 0)
 *      if width < 0 : draw segments in sketch mode, width = abs(width)
 *      Use a value min(aSize.x, aSize.y) / 5 for a bold text
 *  @param aItalic = true to simulate an italic font
 *  @param aBold = true to use a bold font Useful only with default width value (aWidth = 0)
 */
void PLOTTER::text( const wxPoint&              aPos,
                    enum EDA_Colors             aColor,
                    const wxString&             aText,
                    int                         aOrient,
                    const wxSize&               aSize,
                    enum GRTextHorizJustifyType aH_justify,
                    enum GRTextVertJustifyType  aV_justify,
                    int                         aWidth,
                    bool                        aItalic,
                    bool                        aBold )
{
    if( aWidth == 0 && aBold )      // Use default values if aWidth == 0
        aWidth = GetPenSizeForBold( MIN( aSize.x, aSize.y ) );

    if( aWidth >= 0 )
        aWidth = Clamp_Text_PenSize( aWidth, aSize, aBold );
    else
        aWidth = -Clamp_Text_PenSize( -aWidth, aSize, aBold );

    set_current_line_width( aWidth );


    if( aColor >= 0 )
        set_color( aColor );

    DrawGraphicText( NULL, NULL, aPos, aColor, aText,
                     aOrient, aSize,
                     aH_justify, aV_justify,
                     aWidth, aItalic,
                     aBold,
                     NULL,
                     this );
}