/*
 * This program source code file is part of KICAD, a free EDA CAD application.
 *
 * Copyright (C) 1992-2010 jean-pierre.charras
 * Copyright (C) 1992-2010 Kicad Developers, see change_log.txt for contributors.
 *
 * This program 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 2
 * of the License, or (at your option) any later version.
 *
 * This program 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 this program; if not, you may find one here:
 * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
 * or you may search the http://www.gnu.org website for the version 2 license,
 * or you may write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
 */

#include "kbool/booleng.h"

#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <stdlib.h>
#include <math.h>
#include <vector>

#include "potracelib.h"
#include "auxiliary.h"

#ifndef max
    #define max( a, b ) ( ( (a) > (b) ) ? (a) : (b) )
  #endif
  #ifndef min
    #define min( a, b ) ( ( (a) < (b) ) ? (a) : (b) )
  #endif


enum output_format {
    POSTSCRIPT_FMT = 1,
    PCBNEW_FMT,
    EESCHEMA_FMT
};
/* free a potrace bitmap */
static void bm_free(potrace_bitmap_t *bm) {
  if (bm != NULL) {
    free(bm->map);
  }
  free(bm);
}


/* Helper class th handle useful info to convert a bitmpa to
 *  a polygonal object description
 */
class BITMAPCONV_INFO
{
public:
    enum output_format m_Format;
    int m_PixmapWidth;
    int m_PixmapHeight;             // the bitmap size in pixels
    double             m_ScaleX;
    double             m_ScaleY;    // the conversion scale
    potrace_path_t*    m_Paths;     // the list of paths, from potrace (list of lines and bezier curves)
    FILE* m_Outfile;
public:
    BITMAPCONV_INFO();
};

static void BezierToPolyline( std::vector <potrace_dpoint_t>& aCornersBuffer,
                              potrace_dpoint_t                p1,
                              potrace_dpoint_t                p2,
                              potrace_dpoint_t                p3,
                              potrace_dpoint_t                p4 );

static void CreateOutputFile( BITMAPCONV_INFO& aInfo );

static const char* CmpName = "LOGO";


BITMAPCONV_INFO::BITMAPCONV_INFO()
{
    m_Format = POSTSCRIPT_FMT;
    m_PixmapWidth  = 0;
    m_PixmapHeight = 0;
    m_ScaleX  = 1.0;
    m_ScaleY  = 1.0;
    m_Paths   = NULL;
    m_Outfile = NULL;
}


/**
 * Function ArmBoolEng
 * Initialise parameters used in kbool
 * @param aBooleng = pointer to the Bool_Engine to initialise
 * @param aConvertHoles = mode for holes when a boolean operation is made
 *   true: in resulting polygon, holes are linked into outer contours by double overlapping segments
 *   false: in resulting polygons, holes are not linked: they are separate polygons
 */
void ArmBoolEng( Bool_Engine* aBooleng, bool aConvertHoles )
{
    // set some global vals to arm the boolean engine

    // input points are scaled up with GetDGrid() * GetGrid()

    // DGRID is only meant to make fractional parts of input data which

    /*
     *  The input data scaled up with DGrid is related to the accuracy the user has in his input data.
     *  User data with a minimum accuracy of 0.001, means set the DGrid to 1000.
     *  The input data may contain data with a minimum accuracy much smaller, but by setting the DGrid
     *  everything smaller than 1/DGrid is rounded.
     *
     *  DGRID is only meant to make fractional parts of input data which can be
     *  doubles, part of the integers used in vertexes within the boolean algorithm.
     *  And therefore DGRID bigger than 1 is not usefull, you would only loose accuracy.
     *  Within the algorithm all input data is multiplied with DGRID, and the result
     *  is rounded to an integer.
     */
    double DGRID = 1000.0;      // round coordinate X or Y value in calculations to this (initial value = 1000.0 in kbool example)
                                // kbool uses DGRID to convert float user units to integer
                                // kbool unit = (int)(user unit * DGRID)
                                // Note: in kicad, coordinates are already integer so DGRID could be set to 1
                                // we can choose 1.0,
                                // but choose DGRID = 1000.0 solves some filling problems
//                             (perhaps because this allows a better precision in kbool internal calculations

    double MARGE = 1.0 / DGRID;         // snap with in this range points to lines in the intersection routines
                                        // should always be >= 1/DGRID  a  MARGE >= 10/DGRID is ok
                                        // this is also used to remove small segments and to decide when
                                        // two segments are in line. ( initial value = 0.001 )
                                        // For kicad we choose MARGE = 1/DGRID

    double CORRECTIONFACTOR = 0.0;      // correct the polygons by this number: used in BOOL_CORRECTION operation
                                        // this operation shrinks a polygon if CORRECTIONFACTOR < 0
                                        // or stretch it if CORRECTIONFACTOR > 0
                                        // the size change is CORRECTIONFACTOR (holes are correctly handled)
    double CORRECTIONABER = 1.0;        // the accuracy for the rounded shapes used in correction
    double ROUNDFACTOR    = 1.5;        // when will we round the correction shape to a circle
    double SMOOTHABER     = 10.0;       // accuracy when smoothing a polygon
    double MAXLINEMERGE   = 1000.0;     // leave as is, segments of this length in smoothen


    /*
     *    Grid makes sure that the integer data used within the algorithm has room for extra intersections
     *    smaller than the smallest number within the input data.
     *    The input data scaled up with DGrid is related to the accuracy the user has in his input data.
     *    Another scaling with Grid is applied on top of it to create space in the integer number for
     *    even smaller numbers.
     */
    int GRID = (int) ( 10000 / DGRID );    // initial value = 10000 in kbool example

    // But we use 10000/DGRID because the scalling is made
    // by DGRID on integer pcbnew units and
    // the global scalling ( GRID*DGRID) must be < 30000 to avoid
    // overflow in calculations (made in long long in kbool)
    if( GRID <= 1 )     // Cannot be null!
        GRID = 1;

    aBooleng->SetMarge( MARGE );
    aBooleng->SetGrid( GRID );
    aBooleng->SetDGrid( DGRID );
    aBooleng->SetCorrectionFactor( CORRECTIONFACTOR );
    aBooleng->SetCorrectionAber( CORRECTIONABER );
    aBooleng->SetSmoothAber( SMOOTHABER );
    aBooleng->SetMaxlinemerge( MAXLINEMERGE );
    aBooleng->SetRoundfactor( ROUNDFACTOR );
    aBooleng->SetWindingRule( true );           // This is the default kbool value

    if( aConvertHoles )
    {
#if 1                                                       // Can be set to 1 for kbool version >= 2.1, must be set to 0 for previous versions
        // SetAllowNonTopHoleLinking() exists only in kbool >= 2.1
        aBooleng->SetAllowNonTopHoleLinking( false );       // Default = , but i have problems (filling errors) when true
#endif
        aBooleng->SetLinkHoles( true );                     // holes will be connected by double overlapping segments
        aBooleng->SetOrientationEntryMode( false );         // all polygons are contours, not holes
    }
    else
    {
        aBooleng->SetLinkHoles( false );                // holes will not be connected by double overlapping segments
        aBooleng->SetOrientationEntryMode( true );      // holes are entered counter clockwise
    }
}


int bitmap2component( potrace_bitmap_t* aPotrace_bitmap, FILE * aOutfile, int aFormat )
{
    potrace_param_t*  param;
    potrace_state_t*  st;


    /* set tracing parameters, starting from defaults */
    param = potrace_param_default();
    if( !param )
    {
        fprintf( stderr, "Error allocating parameters: %s\n", strerror( errno ) );
        return 1;
    }
    param->turdsize = 0;

    /* convert the bitmap to curves */
    st = potrace_trace( param, aPotrace_bitmap );
    if( !st || st->status != POTRACE_STATUS_OK )
    {
        fprintf( stderr, "Error tracing bitmap: %s\n", strerror( errno ) );
        return 1;
    }

    BITMAPCONV_INFO info;
    info.m_PixmapWidth  = aPotrace_bitmap->w;
    info.m_PixmapHeight = aPotrace_bitmap->h;     // the bitmap size in pixels
    info.m_Paths   = st->plist;
    info.m_Outfile = aOutfile;

    switch( aFormat )
    {
    case 2:
        info.m_Format = POSTSCRIPT_FMT;
        info.m_ScaleX = info.m_ScaleY = 1.0;        // the conversion scale
        /* output vector data, e.g. as a rudimentary EPS file */
        CreateOutputFile( info );
        break;

    case 1:
        info.m_Format = EESCHEMA_FMT;
        info.m_ScaleX = 1000.0 / 300;       // the conversion scale
        info.m_ScaleY = -  info.m_ScaleX;   // Y axis is bottom to Top for components in libs
        CreateOutputFile( info );
        break;

    case 0:
        info.m_Format = PCBNEW_FMT;
        info.m_ScaleX = 10000.0 / 300;       // the conversion scale
        info.m_ScaleY = info.m_ScaleX;       // Y axis is top to bottom in modedit
        CreateOutputFile( info );
        break;

    default:
       break;
    }


    bm_free( aPotrace_bitmap );
    potrace_state_free( st );
    potrace_param_free( param );

    return 0;
}


static void OuputHeader( BITMAPCONV_INFO& aInfo )
{
    int Ypos = (int) ( aInfo.m_PixmapHeight / 2 * aInfo.m_ScaleY );
    int fieldSize;             // fields text size = 60 mils

    switch( aInfo.m_Format )
    {
    case POSTSCRIPT_FMT:
        /* output vector data, e.g. as a rudimentary EPS file */
        fprintf( aInfo.m_Outfile, "%%!PS-Adobe-3.0 EPSF-3.0\n" );
        fprintf( aInfo.m_Outfile, "%%%%BoundingBox: 0 0 %d %d\n",
                 aInfo.m_PixmapWidth, aInfo.m_PixmapHeight );
        fprintf( aInfo.m_Outfile, "gsave\n" );
        break;

    case PCBNEW_FMT:
        #define FIELD_LAYER 21
        fieldSize = 600;             // fields text size = 60 mils
        Ypos += fieldSize / 2;
        fprintf( aInfo.m_Outfile, "PCBNEW-LibModule-V1\n" );
        fprintf( aInfo.m_Outfile, "$INDEX\n%s\n$EndINDEX\n", CmpName );

        fprintf( aInfo.m_Outfile, "#\n# %s\n", CmpName );
        fprintf( aInfo.m_Outfile, "# pixmap w = %d, h = %d\n#\n",
                 aInfo.m_PixmapWidth, aInfo.m_PixmapHeight );
        fprintf( aInfo.m_Outfile, "$MODULE %s\n", CmpName );
        fprintf( aInfo.m_Outfile, "Po 0 0 0 15 00000000 00000000 ~~\n");
        fprintf( aInfo.m_Outfile, "Li %s\n", CmpName );
        fprintf( aInfo.m_Outfile, "T0 0 %d %d %d 0 %d N I %d \"G***\"\n",
                Ypos, fieldSize, fieldSize, fieldSize/5, FIELD_LAYER );
        fprintf( aInfo.m_Outfile, "T1 0 %d %d %d 0 %d N I %d \"%s\"\n",
                -Ypos, fieldSize, fieldSize, fieldSize/5, FIELD_LAYER, CmpName );
        break;

    case EESCHEMA_FMT:
        fprintf( aInfo.m_Outfile, "EESchema-LIBRARY Version 2.3\n" );
        fprintf( aInfo.m_Outfile, "#\n# %s\n", CmpName );
        fprintf( aInfo.m_Outfile, "# pixmap size w = %d, h = %d\n#\n",
                 aInfo.m_PixmapWidth, aInfo.m_PixmapHeight );

        // print reference and value
        fieldSize = 60;             // fields text size = 60 mils
        Ypos += fieldSize / 2;
        fprintf( aInfo.m_Outfile, "DEF %s G 0 40 Y Y 1 F N\n", CmpName );
        fprintf( aInfo.m_Outfile, "F0 \"#G\" 0 %d %d H I C CNN\n", Ypos, fieldSize );
        fprintf( aInfo.m_Outfile, "F1 \"%s\" 0 %d %d H I C CNN\n", CmpName, -Ypos, fieldSize );
        fprintf( aInfo.m_Outfile, "DRAW\n" );
        break;
    }
}


static void OuputEnd( BITMAPCONV_INFO& aInfo )
{
    switch( aInfo.m_Format )
    {
    case POSTSCRIPT_FMT:
        fprintf( aInfo.m_Outfile, "grestore\n" );
        fprintf( aInfo.m_Outfile, "%%EOF\n" );
        break;

    case PCBNEW_FMT:
        fprintf( aInfo.m_Outfile, "$EndMODULE %s\n", CmpName );
        fprintf( aInfo.m_Outfile, "$EndLIBRARY\n" );
        break;

    case EESCHEMA_FMT:
        fprintf( aInfo.m_Outfile, "ENDDRAW\n" );
        fprintf( aInfo.m_Outfile, "ENDDEF\n" );
        break;
    }
}


static void OuputOnePolygon( BITMAPCONV_INFO&                aInfo,
                             std::vector <potrace_dpoint_t>& aPolygonBuffer )
{
    unsigned ii;

    double   offsetX = aInfo.m_PixmapWidth / 2 * aInfo.m_ScaleX;
    double   offsetY = aInfo.m_PixmapHeight / 2 * aInfo.m_ScaleY;

    switch( aInfo.m_Format )
    {
    case POSTSCRIPT_FMT:
        fprintf( aInfo.m_Outfile, "%f %f moveto\n",
                 aPolygonBuffer[0].x * aInfo.m_ScaleX,
                 aPolygonBuffer[0].y * aInfo.m_ScaleY );
        for( ii = 1; ii < aPolygonBuffer.size(); ii++ )
            fprintf( aInfo.m_Outfile, "%f %f lineto\n",
                     aPolygonBuffer[ii].x * aInfo.m_ScaleX,
                     aPolygonBuffer[ii].y * aInfo.m_ScaleY );

        fprintf( aInfo.m_Outfile, "0 setgray fill\n" );
        break;

    case PCBNEW_FMT:
    {
        #define SILKSCREEN_N_FRONT 21
        int layer = SILKSCREEN_N_FRONT;
        int width = 1;
        fprintf( aInfo.m_Outfile, "DP %d %d %d %d %d %d %d\n",
                       0, 0, 0, 0,
                       int(aPolygonBuffer.size()+1),
                       width, layer );

        for( ii = 0; ii < aPolygonBuffer.size();  ii++ )
            fprintf( aInfo.m_Outfile, "Dl %d %d\n",
                    (int) ( aPolygonBuffer[ii].x * aInfo.m_ScaleX - offsetX ),
                    (int) ( aPolygonBuffer[ii].y * aInfo.m_ScaleY - offsetY ) );
        // Close polygon
        fprintf( aInfo.m_Outfile, "Dl %d %d\n",
                (int) ( aPolygonBuffer[0].x * aInfo.m_ScaleX - offsetX ),
                (int) ( aPolygonBuffer[0].y * aInfo.m_ScaleY - offsetY ) );
    }
        break;

    case EESCHEMA_FMT:
        fprintf( aInfo.m_Outfile, "P %d 0 0 1", int(aPolygonBuffer.size()+1) );
        for( ii = 0; ii < aPolygonBuffer.size(); ii++ )
            fprintf( aInfo.m_Outfile, " %d %d",
                    (int) ( aPolygonBuffer[ii].x * aInfo.m_ScaleX - offsetX ),
                    (int) ( aPolygonBuffer[ii].y * aInfo.m_ScaleY - offsetY ) );
       // Close polygon
        fprintf( aInfo.m_Outfile, " %d %d",
                (int) ( aPolygonBuffer[0].x * aInfo.m_ScaleX - offsetX ),
                (int) ( aPolygonBuffer[0].y * aInfo.m_ScaleY - offsetY ) );

        fprintf( aInfo.m_Outfile, " F\n" );
        break;
    }
}


static void CreateOutputFile( BITMAPCONV_INFO& aInfo )
{
    unsigned int i, n;
    int*         tag;

    std::vector <potrace_dpoint_t> cornersBuffer;

    potrace_dpoint_t( *c )[3];
    OuputHeader( aInfo );

    bool         main_outline = true;
    Bool_Engine* booleng = NULL;

    /* draw each as a polygon with no hole.
     * Bezier curves are approximated by a polyline
     */
    potrace_path_t* paths = aInfo.m_Paths;    // the list of paths
    while( paths != NULL )
    {
        n   = paths->curve.n;
        tag = paths->curve.tag;
        c   = paths->curve.c;
        potrace_dpoint_t startpoint = c[n - 1][2];
        cornersBuffer.push_back( startpoint );
        if( booleng == NULL )
        {
            booleng = new Bool_Engine();
            ArmBoolEng( booleng, true );
        }
        for( i = 0; i < n; i++ )
        {
            switch( tag[i] )
            {
            case POTRACE_CORNER:
                cornersBuffer.push_back( c[i][1] );
                cornersBuffer.push_back( c[i][2] );
                startpoint = c[i][2];
                break;

            case POTRACE_CURVETO:
                BezierToPolyline( cornersBuffer, startpoint, c[i][0], c[i][1], c[i][2] );
                startpoint = c[i][2];
                break;
            }
        }

        // Store current path
        if( main_outline )
        {
            main_outline = false;
            booleng->StartPolygonAdd( GROUP_A );
            for( i = 1; i < cornersBuffer.size(); i++ )
                booleng->AddPoint( cornersBuffer[i].x, cornersBuffer[i].y );

            booleng->EndPolygonAdd();
        }
        else
        {
            booleng->StartPolygonAdd( GROUP_B );
            for( i = 1; i < cornersBuffer.size(); i++ )
                booleng->AddPoint( cornersBuffer[i].x, cornersBuffer[i].y );

            booleng->EndPolygonAdd();
        }
        cornersBuffer.clear();

        /* at the end of a group of a positive path and its negative
         *  children, fill. */
        if( paths->next == NULL || paths->next->sign == '+' )
        {
            booleng->Do_Operation( BOOL_A_SUB_B );
            std::vector <potrace_dpoint_t> PolygonBuffer;
            while( booleng->StartPolygonGet() )
            {
                potrace_dpoint_t corner;
                PolygonBuffer.clear();
                while( booleng->PolygonHasMorePoints() )
                {
                    corner.x = booleng->GetPolygonXPoint();
                    corner.y = booleng->GetPolygonYPoint();
                    PolygonBuffer.push_back( corner );
                }

                booleng->EndPolygonGet();
                OuputOnePolygon( aInfo, PolygonBuffer );
                PolygonBuffer.clear();
            }

            delete booleng;
            booleng = NULL;
            main_outline = true;
        }
        paths = paths->next;
    }

    OuputEnd( aInfo );
}


/* render a Bezier curve. */
void BezierToPolyline( std::vector <potrace_dpoint_t>& aCornersBuffer,
                       potrace_dpoint_t                p1,
                       potrace_dpoint_t                p2,
                       potrace_dpoint_t                p3,
                       potrace_dpoint_t                p4 )
{
    double dd0, dd1, dd, delta, e2, epsilon, t;

    // p1 = starting point

    /* we approximate the curve by small line segments. The interval
     *  size, epsilon, is determined on the fly so that the distance
     *  between the true curve and its approximation does not exceed the
     *  desired accuracy delta. */

    delta = 0.5; /* desired accuracy, in pixels */

    /* let dd = maximal value of 2nd derivative over curve - this must
     *  occur at an endpoint. */
    dd0     = sq( p1.x - 2 * p2.x + p3.x ) + sq( p1.y - 2 * p2.y + p3.y );
    dd1     = sq( p2.x - 2 * p3.x + p4.x ) + sq( p2.y - 2 * p3.y + p4.y );
    dd      = 6 * sqrt( max( dd0, dd1 ) );
    e2      = 8 * delta <= dd ? 8 * delta / dd : 1;
    epsilon = sqrt( e2 ); /* necessary interval size */

    for( t = epsilon; t<1; t += epsilon )
    {
        potrace_dpoint_t intermediate_point;
        intermediate_point.x = p1.x * cu( 1 - t ) +
                               3* p2.x* sq( 1 - t ) * t +
                               3 * p3.x * (1 - t) * sq( t ) +
                               p4.x*    cu( t );

        intermediate_point.y = p1.y * cu( 1 - t ) +
                               3* p2.y* sq( 1 - t ) * t +
                               3 * p3.y * (1 - t) * sq( t ) + p4.y* cu( t );

        aCornersBuffer.push_back( intermediate_point );
    }

    aCornersBuffer.push_back( p4 );
}
