/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright (C) 2012 SoftPLC Corporation, Dick Hollenbeck <dick@softplc.com>
 * Copyright (C) 2012-2021 KiCad Developers, see AUTHORS.txt for contributors.
 * Copyright (C) 2017 CERN.
 *
 * @author Alejandro García Montoro <alejandro.garciamontoro@gmail.com>
 *
 * 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 <plugins/eagle/eagle_parser.h>

#include <string_utils.h>
#include <richio.h>
#include <wx/log.h>

#include <functional>
#include <cstdio>

constexpr auto DEFAULT_ALIGNMENT = ETEXT::BOTTOM_LEFT;


wxString escapeName( const wxString& aNetName )
{
    wxString ret( aNetName );

    ret.Replace( wxT( "!" ), wxT( "~" ) );

    return ConvertToNewOverbarNotation( ret );
}


template<> template<>
OPTIONAL_XML_ATTRIBUTE<wxString>::OPTIONAL_XML_ATTRIBUTE( wxString aData )
{
    m_isAvailable = !aData.IsEmpty();

    if( m_isAvailable )
        Set( aData );
}


ECOORD::ECOORD( const wxString& aValue, enum ECOORD::EAGLE_UNIT aUnit )
{
    // This array is used to adjust the fraction part value basing on the number of digits
    // in the fraction.
    constexpr int DIVIDERS[] = { 1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000 };
    constexpr unsigned int DIVIDERS_MAX_IDX = sizeof( DIVIDERS ) / sizeof( DIVIDERS[0] ) - 1;

    int integer, fraction, pre_fraction, post_fraction;

    // The following check is needed to handle correctly negative fractions where the integer
    // part == 0.
    bool negative = ( aValue[0] == '-' );

    // %n is used to find out how many digits contains the fraction part, e.g. 0.001 contains 3
    // digits.
    int ret = sscanf( aValue.c_str(), "%d.%n%d%n", &integer, &pre_fraction, &fraction,
                      &post_fraction );

    if( ret == 0 )
        throw XML_PARSER_ERROR( "Invalid coordinate" );

    // process the integer part
    value = ConvertToNm( integer, aUnit );

    // process the fraction part
    if( ret == 2 )
    {
        int digits = post_fraction - pre_fraction;

        // adjust the number of digits if necessary as we cannot handle anything smaller than
        // nanometers (rounding).
        if( (unsigned) digits > DIVIDERS_MAX_IDX )
        {
            int diff = digits - DIVIDERS_MAX_IDX;
            digits = DIVIDERS_MAX_IDX;
            fraction /= DIVIDERS[diff];
        }

        int frac_value = ConvertToNm( fraction, aUnit ) / DIVIDERS[digits];

        // keep the sign in mind
        value = negative ? value - frac_value : value + frac_value;
    }
}


long long int ECOORD::ConvertToNm( int aValue, enum EAGLE_UNIT aUnit )
{
    long long int ret;

    switch( aUnit )
    {
        default:
        case EU_NM:    ret = aValue; break;
        case EU_MM:    ret = (long long) aValue * 1000000; break;
        case EU_INCH:  ret = (long long) aValue * 25400000; break;
        case EU_MIL:   ret = (long long) aValue * 25400; break;
    }

    if( ( ret > 0 ) != ( aValue > 0 ) )
        wxLogError( _( "Invalid size %lld: too large" ), aValue );

    return ret;
}


// Template specializations below parse wxString to the used types:
//      - wxString (preferred)
//      - string
//      - double
//      - int
//      - bool
//      - EROT
//      - ECOORD

template <>
wxString Convert<wxString>( const wxString& aValue )
{
    return aValue;
}


template <>
std::string Convert<std::string>( const wxString& aValue )
{
    return std::string( aValue.ToUTF8() );
}


template <>
double Convert<double>( const wxString& aValue )
{
    double value;

    if( aValue.ToCDouble( &value ) )
        return value;
    else
        throw XML_PARSER_ERROR( "Conversion to double failed. Original value: '" +
                                aValue.ToStdString() + "'." );
}


template <>
int Convert<int>( const wxString& aValue )
{
    if( aValue.IsEmpty() )
        throw XML_PARSER_ERROR( "Conversion to int failed. Original value is empty." );

    return wxAtoi( aValue );
}


template <>
bool Convert<bool>( const wxString& aValue )
{
    if( aValue != wxT( "yes" ) && aValue != wxT( "no" ) )
        throw XML_PARSER_ERROR( "Conversion to bool failed. Original value, '" +
                                aValue.ToStdString() +
                                "', is neither 'yes' nor 'no'." );

    return aValue == wxT( "yes" );
}


/// parse an Eagle XML "rot" field.  Unfortunately the DTD seems not to explain
/// this format very well.  [S][M]R<degrees>.   Examples: "R90", "MR180", "SR180"
template<>
EROT Convert<EROT>( const wxString& aRot )
{
    EROT value;

    value.spin    = aRot.find( 'S' ) != aRot.npos;
    value.mirror  = aRot.find( 'M' ) != aRot.npos;
    value.degrees = strtod( aRot.c_str()
                            + 1                        // skip leading 'R'
                            + int( value.spin )       // skip optional leading 'S'
                            + int( value.mirror ),    // skip optional leading 'M'
                            nullptr );

    return value;
}


template<>
ECOORD Convert<ECOORD>( const wxString& aCoord )
{
    // Eagle uses millimeters as the default unit
    return ECOORD( aCoord, ECOORD::EAGLE_UNIT::EU_MM );
}


/**
 * Parse \a aAttribute of the XML node \a aNode.
 *
 * @param  aNode      is the node whose attribute will be parsed.
 * @param  aAttribute is the attribute that will be parsed.
 * @throw  XML_PARSER_ERROR - exception thrown if the required attribute is missing
 * @return T - the attributed parsed as the specified type.
 */
template<typename T>
T parseRequiredAttribute( wxXmlNode* aNode, const wxString& aAttribute )
{
    wxString value;

    if( aNode->GetAttribute( aAttribute, &value ) )
        return Convert<T>( value );
    else
        throw XML_PARSER_ERROR( "The required attribute " + aAttribute + " is missing." );
}


/**
 * Parse option \a aAttribute of the XML node \a aNode.
 *
 * @param  aNode      is the node whose attribute will be parsed.
 * @param  aAttribute is the attribute that will be parsed.
 * @return OPTIONAL_XML_ATTRIBUTE<T> - an optional XML attribute, parsed as the specified type if
 *                                     found.
 */
template<typename T>
OPTIONAL_XML_ATTRIBUTE<T> parseOptionalAttribute( wxXmlNode* aNode, const wxString& aAttribute )
{
    return OPTIONAL_XML_ATTRIBUTE<T>( aNode->GetAttribute( aAttribute ) );
}


NODE_MAP MapChildren( wxXmlNode* aCurrentNode )
{
    // Map node_name -> node_pointer
    NODE_MAP nodesMap;

    // Loop through all children mapping them in nodesMap
    if( aCurrentNode )
        aCurrentNode = aCurrentNode->GetChildren();

    while( aCurrentNode )
    {
        // Create a new pair in the map
        //      key: current node name
        //      value: current node pointer
        nodesMap[aCurrentNode->GetName()] = aCurrentNode;

        // Get next child
        aCurrentNode = aCurrentNode->GetNext();
    }

    return nodesMap;
}


wxPoint ConvertArcCenter( const wxPoint& aStart, const wxPoint& aEnd, double aAngle )
{
    // Eagle give us start and end.
    // S_ARC wants start to give the center, and end to give the start.
    double dx = aEnd.x - aStart.x, dy = aEnd.y - aStart.y;
    wxPoint mid = ( aStart + aEnd ) / 2;

    double dlen = sqrt( dx*dx + dy*dy );

    if( !std::isnormal( dlen ) || !std::isnormal( aAngle ) )
    {
        THROW_IO_ERROR( wxString::Format( _( "Invalid Arc with radius %f and angle %f" ),
                                          dlen,
                                          aAngle ) );
    }

    double dist = dlen / ( 2 * tan( DEG2RAD( aAngle ) / 2 ) );

    wxPoint center(
        mid.x + dist * ( dy / dlen ),
        mid.y - dist * ( dx / dlen )
    );

    return center;
}


static int parseAlignment( const wxString& aAlignment )
{
    // (bottom-left | bottom-center | bottom-right | center-left |
    // center | center-right | top-left | top-center | top-right)
    if( aAlignment == wxT( "center" ) )
        return ETEXT::CENTER;
    else if( aAlignment == wxT( "center-right" ) )
        return ETEXT::CENTER_RIGHT;
    else if( aAlignment == wxT( "top-left" ) )
        return ETEXT::TOP_LEFT;
    else if( aAlignment == wxT( "top-center" ) )
        return ETEXT::TOP_CENTER;
    else if( aAlignment == wxT( "top-right" ) )
        return ETEXT::TOP_RIGHT;
    else if( aAlignment == wxT( "bottom-left" ) )
        return ETEXT::BOTTOM_LEFT;
    else if( aAlignment == wxT( "bottom-center" ) )
        return ETEXT::BOTTOM_CENTER;
    else if( aAlignment == wxT( "bottom-right" ) )
        return ETEXT::BOTTOM_RIGHT;
    else if( aAlignment == wxT( "center-left" ) )
        return ETEXT::CENTER_LEFT;

    return DEFAULT_ALIGNMENT;
}


EWIRE::EWIRE( wxXmlNode* aWire )
{
    /*
        <!ELEMENT wire EMPTY>
        <!ATTLIST wire
            x1            %Coord;        #REQUIRED
            y1            %Coord;        #REQUIRED
            x2            %Coord;        #REQUIRED
            y2            %Coord;        #REQUIRED
            width         %Dimension;    #REQUIRED
            layer         %Layer;        #REQUIRED
            extent        %Extent;       #IMPLIED  -- only applicable for airwires --
            style         %WireStyle;    "continuous"
            curve         %WireCurve;    "0"
            cap           %WireCap;      "round"   -- only applicable if 'curve' is not zero --
        >
    */

    x1    = parseRequiredAttribute<ECOORD>( aWire, wxT( "x1" ) );
    y1    = parseRequiredAttribute<ECOORD>( aWire, wxT( "y1" ) );
    x2    = parseRequiredAttribute<ECOORD>( aWire, wxT( "x2" ) );
    y2    = parseRequiredAttribute<ECOORD>( aWire, wxT( "y2" ) );
    width = parseRequiredAttribute<ECOORD>( aWire, wxT( "width" ) );
    layer = parseRequiredAttribute<int>( aWire, wxT( "layer" ) );
    curve = parseOptionalAttribute<double>( aWire, wxT( "curve" ) );

    opt_wxString s = parseOptionalAttribute<wxString>( aWire, wxT( "style" ) );

    if( s == wxT( "continuous" ) )
        style = EWIRE::CONTINUOUS;
    else if( s == wxT( "longdash" ) )
        style = EWIRE::LONGDASH;
    else if( s == wxT( "shortdash" ) )
        style = EWIRE::SHORTDASH;
    else if( s == wxT( "dashdot" ) )
        style = EWIRE::DASHDOT;

    s = parseOptionalAttribute<wxString>( aWire, wxT( "cap" ) );

    if( s == wxT( "round" ) )
        cap = EWIRE::ROUND;
    else if( s == wxT( "flat" ) )
        cap = EWIRE::FLAT;
}


EJUNCTION::EJUNCTION( wxXmlNode* aJunction )
{
    /*
    <!ELEMENT junction EMPTY>
    <!ATTLIST junction
          x             %Coord;        #REQUIRED
          y             %Coord;        #REQUIRED
          >
    */

    x    = parseRequiredAttribute<ECOORD>( aJunction, wxT( "x" ) );
    y    = parseRequiredAttribute<ECOORD>( aJunction, wxT( "y" ) );
}


ELABEL::ELABEL( wxXmlNode* aLabel, const wxString& aNetName )
{
    /*
    <!ELEMENT label EMPTY>
    <!ATTLIST label
          x             %Coord;        #REQUIRED
          y             %Coord;        #REQUIRED
          size          %Dimension;    #REQUIRED
          layer         %Layer;        #REQUIRED
          font          %TextFont;     "proportional"
          ratio         %Int;          "8"
          rot           %Rotation;     "R0"
          xref          %Bool;         "no"
          >
    */

    x    = parseRequiredAttribute<ECOORD>( aLabel, wxT( "x" ) );
    y    = parseRequiredAttribute<ECOORD>( aLabel, wxT( "y" ) );
    size = parseRequiredAttribute<ECOORD>( aLabel, wxT( "size" ) );
    layer = parseRequiredAttribute<int>( aLabel, wxT( "layer" ) );
    rot   = parseOptionalAttribute<EROT>( aLabel, wxT( "rot" ) );
    xref  = parseOptionalAttribute<wxString>( aLabel, wxT( "xref" ) );
    netname = aNetName;
}


EVIA::EVIA( wxXmlNode* aVia )
{
    /*
    <!ELEMENT via EMPTY>
    <!ATTLIST via
          x             %Coord;        #REQUIRED
          y             %Coord;        #REQUIRED
          extent        %Extent;       #REQUIRED
          drill         %Dimension;    #REQUIRED
          diameter      %Dimension;    "0"
          shape         %ViaShape;     "round"
          alwaysstop    %Bool;         "no"
          >
    */

    x = parseRequiredAttribute<ECOORD>( aVia, wxT( "x" ) );
    y = parseRequiredAttribute<ECOORD>( aVia, wxT( "y" ) );

    wxString ext = parseRequiredAttribute<wxString>( aVia, wxT( "extent" ) );
    sscanf( ext.c_str(), "%d-%d", &layer_front_most, &layer_back_most );

    drill = parseRequiredAttribute<ECOORD>( aVia, wxT( "drill" ) );
    diam  = parseOptionalAttribute<ECOORD>( aVia, wxT( "diameter" ) );
    shape = parseOptionalAttribute<wxString>( aVia, wxT( "shape" ) );
}


ECIRCLE::ECIRCLE( wxXmlNode* aCircle )
{
    /*
    <!ELEMENT circle EMPTY>
    <!ATTLIST circle
          x             %Coord;        #REQUIRED
          y             %Coord;        #REQUIRED
          radius        %Coord;        #REQUIRED
          width         %Dimension;    #REQUIRED
          layer         %Layer;        #REQUIRED
          >
    */

    x      = parseRequiredAttribute<ECOORD>( aCircle, wxT( "x" ) );
    y      = parseRequiredAttribute<ECOORD>( aCircle, wxT( "y" ) );
    radius = parseRequiredAttribute<ECOORD>( aCircle, wxT( "radius" ) );
    width  = parseRequiredAttribute<ECOORD>( aCircle, wxT( "width" ) );
    layer  = parseRequiredAttribute<int>( aCircle, wxT( "layer" ) );
}


ERECT::ERECT( wxXmlNode* aRect )
{
    /*
    <!ELEMENT rectangle EMPTY>
    <!ATTLIST rectangle
          x1            %Coord;        #REQUIRED
          y1            %Coord;        #REQUIRED
          x2            %Coord;        #REQUIRED
          y2            %Coord;        #REQUIRED
          layer         %Layer;        #REQUIRED
          rot           %Rotation;     "R0"
          >
    */

    x1    = parseRequiredAttribute<ECOORD>( aRect, wxT( "x1" ) );
    y1    = parseRequiredAttribute<ECOORD>( aRect, wxT( "y1" ) );
    x2    = parseRequiredAttribute<ECOORD>( aRect, wxT( "x2" ) );
    y2    = parseRequiredAttribute<ECOORD>( aRect, wxT( "y2" ) );
    layer = parseRequiredAttribute<int>( aRect, wxT( "layer" ) );
    rot   = parseOptionalAttribute<EROT>( aRect, wxT( "rot" ) );
}


EATTR::EATTR( wxXmlNode* aTree )
{
    /*
    <!ELEMENT attribute EMPTY>
    <!ATTLIST attribute
        name          %String;       #REQUIRED
        value         %String;       #IMPLIED
        x             %Coord;        #IMPLIED
        y             %Coord;        #IMPLIED
        size          %Dimension;    #IMPLIED
        layer         %Layer;        #IMPLIED
        font          %TextFont;     #IMPLIED
        ratio         %Int;          #IMPLIED
        rot           %Rotation;     "R0"
        display       %AttributeDisplay; "value" -- only in <element> or <instance> context --
        constant      %Bool;         "no"     -- only in <device> context --
        >
    */

    name  = parseRequiredAttribute<wxString>( aTree, wxT( "name" ) );
    value = parseOptionalAttribute<wxString>( aTree, wxT( "value" ) );

    x     = parseOptionalAttribute<ECOORD>( aTree, wxT( "x" ) );
    y     = parseOptionalAttribute<ECOORD>( aTree, wxT( "y" ) );
    size  = parseOptionalAttribute<ECOORD>( aTree, wxT( "size" ) );

    layer = parseOptionalAttribute<int>( aTree, wxT( "layer" ) );
    ratio = parseOptionalAttribute<double>( aTree, wxT( "ratio" ) );
    rot   = parseOptionalAttribute<EROT>( aTree, wxT( "rot" ) );

    opt_wxString stemp = parseOptionalAttribute<wxString>( aTree, wxT( "display" ) );

    // (off | value | name | both)
    if( stemp == wxT( "off" ) )
        display = EATTR::Off;
    else if( stemp == wxT( "name" ) )
        display = EATTR::NAME;
    else if( stemp == wxT( "both" ) )
        display = EATTR::BOTH;
    else // "value" is the default
        display = EATTR::VALUE;

    stemp = parseOptionalAttribute<wxString>( aTree, wxT( "align" ) );

    align = stemp ? parseAlignment( *stemp ) : DEFAULT_ALIGNMENT;
}


EDIMENSION::EDIMENSION( wxXmlNode* aDimension )
{
    /*
    <!ELEMENT dimension EMPTY>
    <!ATTLIST dimension
          x1            %Coord;        #REQUIRED
          y1            %Coord;        #REQUIRED
          x2            %Coord;        #REQUIRED
          y2            %Coord;        #REQUIRED
          x3            %Coord;        #REQUIRED
          y3            %Coord;        #REQUIRED
          textsize      %Coord;
          layer         %Layer;        #REQUIRED
          dtype         %DimensionType; "parallel"
          >
    */

    x1       = parseRequiredAttribute<ECOORD>( aDimension, wxT( "x1" ) );
    y1       = parseRequiredAttribute<ECOORD>( aDimension, wxT( "y1" ) );
    x2       = parseRequiredAttribute<ECOORD>( aDimension, wxT( "x2" ) );
    y2       = parseRequiredAttribute<ECOORD>( aDimension, wxT( "y2" ) );
    x3       = parseRequiredAttribute<ECOORD>( aDimension, wxT( "x3" ) );
    y3       = parseRequiredAttribute<ECOORD>( aDimension, wxT( "y3" ) );
    textsize = parseOptionalAttribute<ECOORD>( aDimension, wxT( "textsize" ) );
    layer    = parseRequiredAttribute<int>( aDimension, wxT( "layer" ) );
    dimensionType = parseOptionalAttribute<wxString>( aDimension, wxT( "dtype" ) );
}


ETEXT::ETEXT( wxXmlNode* aText )
{
    /*
    <!ELEMENT text (#PCDATA)>
    <!ATTLIST text
          x             %Coord;        #REQUIRED
          y             %Coord;        #REQUIRED
          size          %Dimension;    #REQUIRED
          layer         %Layer;        #REQUIRED
          font          %TextFont;     "proportional"
          ratio         %Int;          "8"
          rot           %Rotation;     "R0"
          align         %Align;        "bottom-left"
          >
    */

    text  = aText->GetNodeContent();
    x     = parseRequiredAttribute<ECOORD>( aText, wxT( "x" ) );
    y     = parseRequiredAttribute<ECOORD>( aText, wxT( "y" ) );
    size  = parseRequiredAttribute<ECOORD>( aText, wxT( "size" ) );
    layer = parseRequiredAttribute<int>( aText, wxT( "layer" ) );

    font  = parseOptionalAttribute<wxString>( aText, wxT( "font" ) );
    ratio = parseOptionalAttribute<double>( aText, wxT( "ratio" ) );
    rot   = parseOptionalAttribute<EROT>( aText, wxT( "rot" ) );

    opt_wxString stemp = parseOptionalAttribute<wxString>( aText, wxT( "align" ) );

    align = stemp ? parseAlignment( *stemp ) : DEFAULT_ALIGNMENT;
}


wxSize ETEXT::ConvertSize() const
{
    wxSize textsize;

    if( font )
    {
        const wxString& fontName = font.CGet();

        if( fontName == wxT( "vector" ) )
        {
            textsize = wxSize( size.ToSchUnits(), size.ToSchUnits() );
        }
        else if( fontName == wxT( "fixed" ) )
        {
            textsize = wxSize( size.ToSchUnits(), size.ToSchUnits() * 0.80 );
        }
        else
        {
            textsize = wxSize( size.ToSchUnits(), size.ToSchUnits() );
        }
    }
    else
    {
        textsize = wxSize( size.ToSchUnits() * 0.85, size.ToSchUnits() );
    }

    return textsize;
}


EFRAME::EFRAME( wxXmlNode* aFrameNode )
{
    /*
     * <!ELEMENT frame EMPTY>
     * <!ATTLIST frame
     *          x1            %Coord;       #REQUIRED
     *          y1            %Coord;       #REQUIRED
     *          x2            %Coord;       #REQUIRED
     *          y2            %Coord;       #REQUIRED
     *          columns       %Int;         #REQUIRED
     *          rows          %Int;         #REQUIRED
     *          layer         %Layer;       #REQUIRED
     *          border-left   %Bool;        "yes"
     *          border-top    %Bool;        "yes"
     *          border-right  %Bool;        "yes"
     *          border-bottom %Bool;        "yes"
     *          >
     */
    border_left = true;
    border_top = true;
    border_right = true;
    border_bottom = true;

    x1 = parseRequiredAttribute<ECOORD>( aFrameNode, wxT( "x1" ) );
    y1 = parseRequiredAttribute<ECOORD>( aFrameNode, wxT( "y1" ) );
    x2 = parseRequiredAttribute<ECOORD>( aFrameNode, wxT( "x2" ) );
    y2 = parseRequiredAttribute<ECOORD>( aFrameNode, wxT( "y2" ) );
    columns = parseRequiredAttribute<int>( aFrameNode, wxT( "columns" ) );
    rows = parseRequiredAttribute<int>( aFrameNode, wxT( "rows" ) );
    layer = parseRequiredAttribute<int>( aFrameNode, wxT( "layer" ) );
    border_left = parseOptionalAttribute<bool>( aFrameNode, wxT( "border-left" ) );
    border_top = parseOptionalAttribute<bool>( aFrameNode, wxT( "border-top" ) );
    border_right = parseOptionalAttribute<bool>( aFrameNode, wxT( "border-right" ) );
    border_bottom = parseOptionalAttribute<bool>( aFrameNode, wxT( "border-bottom" ) );
}


EPAD_COMMON::EPAD_COMMON( wxXmlNode* aPad )
{
    // #REQUIRED says DTD, throw exception if not found
    name      = parseRequiredAttribute<wxString>( aPad, wxT( "name" ) );
    x         = parseRequiredAttribute<ECOORD>( aPad, wxT( "x" ) );
    y         = parseRequiredAttribute<ECOORD>( aPad, wxT( "y" ) );
    rot      = parseOptionalAttribute<EROT>( aPad, wxT( "rot" ) );
    stop     = parseOptionalAttribute<bool>( aPad, wxT( "stop" ) );
    thermals = parseOptionalAttribute<bool>( aPad, wxT( "thermals" ) );
}


EPAD::EPAD( wxXmlNode* aPad )
    : EPAD_COMMON( aPad )
{
    /*
    <!ELEMENT pad EMPTY>
    <!ATTLIST pad
          name          %String;       #REQUIRED
          x             %Coord;        #REQUIRED
          y             %Coord;        #REQUIRED
          drill         %Dimension;    #REQUIRED
          diameter      %Dimension;    "0"
          shape         %PadShape;     "round"
          rot           %Rotation;     "R0"
          stop          %Bool;         "yes"
          thermals      %Bool;         "yes"
          first         %Bool;         "no"
          >
    */

    // #REQUIRED says DTD, throw exception if not found
    drill        = parseRequiredAttribute<ECOORD>( aPad, wxT( "drill" ) );

    // Optional attributes
    diameter     = parseOptionalAttribute<ECOORD>( aPad, wxT( "diameter" ) );

    opt_wxString s = parseOptionalAttribute<wxString>( aPad, wxT( "shape" ) );

    // (square | round | octagon | long | offset)
    if( s == wxT( "square" ) )
        shape = EPAD::SQUARE;
    else if( s == wxT( "round" ) )
        shape = EPAD::ROUND;
    else if( s == wxT( "octagon" ) )
        shape = EPAD::OCTAGON;
    else if( s == wxT( "long" ) )
        shape = EPAD::LONG;
    else if( s == wxT( "offset" ) )
        shape = EPAD::OFFSET;

    first    = parseOptionalAttribute<bool>( aPad, wxT( "first" ) );
}


ESMD::ESMD( wxXmlNode* aSMD )
    : EPAD_COMMON( aSMD )
{
    /*
    <!ATTLIST smd
          name          %String;       #REQUIRED
          x             %Coord;        #REQUIRED
          y             %Coord;        #REQUIRED
          dx            %Dimension;    #REQUIRED
          dy            %Dimension;    #REQUIRED
          layer         %Layer;        #REQUIRED
          roundness     %Int;          "0"
          rot           %Rotation;     "R0"
          stop          %Bool;         "yes"
          thermals      %Bool;         "yes"
          cream         %Bool;         "yes"
          >
    */

    // DTD #REQUIRED, throw exception if not found
    dx        = parseRequiredAttribute<ECOORD>( aSMD, wxT( "dx" ) );
    dy        = parseRequiredAttribute<ECOORD>( aSMD, wxT( "dy" ) );
    layer     = parseRequiredAttribute<int>( aSMD, wxT( "layer" ) );

    roundness = parseOptionalAttribute<int>( aSMD, wxT( "roundness" ) );
    cream     = parseOptionalAttribute<bool>( aSMD, wxT( "cream" ) );
}


EPIN::EPIN( wxXmlNode* aPin )
{
    /*
    <!ELEMENT pin EMPTY>
    <!ATTLIST pin
              name          %String;       #REQUIRED
              x             %Coord;        #REQUIRED
              y             %Coord;        #REQUIRED
              visible       %PinVisible;   "both"
              length        %PinLength;    "long"
              direction     %PinDirection; "io"
              function      %PinFunction;  "none"
              swaplevel     %Int;          "0"
              rot           %Rotation;     "R0"
              >
    */

    // DTD #REQUIRED, throw exception if not found
    name      = parseRequiredAttribute<wxString>( aPin, wxT( "name" ) );
    x         = parseRequiredAttribute<ECOORD>( aPin, wxT( "x" ) );
    y         = parseRequiredAttribute<ECOORD>( aPin, wxT( "y" ) );

    visible   = parseOptionalAttribute<wxString>( aPin, wxT( "visible" ) );
    length    = parseOptionalAttribute<wxString>( aPin, wxT( "length" ) );
    direction = parseOptionalAttribute<wxString>( aPin, wxT( "direction" ) );
    function  = parseOptionalAttribute<wxString>( aPin, wxT( "function" ) );
    swaplevel = parseOptionalAttribute<int>( aPin, wxT( "swaplevel" ) );
    rot       = parseOptionalAttribute<EROT>( aPin, wxT( "rot" ) );
}


EVERTEX::EVERTEX( wxXmlNode* aVertex )
{
    /*
    <!ELEMENT vertex EMPTY>
    <!ATTLIST vertex
          x             %Coord;        #REQUIRED
          y             %Coord;        #REQUIRED
          curve         %WireCurve;    "0" -- the curvature from this vertex to the next one --
          >
    */

    x = parseRequiredAttribute<ECOORD>( aVertex, wxT( "x" ) );
    y = parseRequiredAttribute<ECOORD>( aVertex, wxT( "y" ) );
    curve = parseOptionalAttribute<double>( aVertex, wxT( "curve" ) );
}


EPOLYGON::EPOLYGON( wxXmlNode* aPolygon )
{
    /*
    <!ATTLIST polygon
          width         %Dimension;    #REQUIRED
          layer         %Layer;        #REQUIRED
          spacing       %Dimension;    #IMPLIED
          pour          %PolygonPour;  "solid"
          isolate       %Dimension;    #IMPLIED -- only in <signal> or <package> context --
          orphans       %Bool;         "no"  -- only in <signal> context --
          thermals      %Bool;         "yes" -- only in <signal> context --
          rank          %Int;          "0"   -- 1..6 in <signal> context, 0 or 7 in
                                                <package> context --
          >
    */

    width        = parseRequiredAttribute<ECOORD>( aPolygon, wxT( "width" ) );
    layer        = parseRequiredAttribute<int>( aPolygon, wxT( "layer" ) );

    spacing      = parseOptionalAttribute<ECOORD>( aPolygon, wxT( "spacing" ) );
    isolate      = parseOptionalAttribute<ECOORD>( aPolygon, wxT( "isolate" ) );
    opt_wxString s = parseOptionalAttribute<wxString>( aPolygon, wxT( "pour" ) );

    // default pour to solid fill
    pour = EPOLYGON::SOLID;

    // (solid | hatch | cutout)
    if( s == wxT( "hatch" ) )
        pour = EPOLYGON::HATCH;
    else if( s == wxT( "cutout" ) )
        pour = EPOLYGON::CUTOUT;

    orphans  = parseOptionalAttribute<bool>( aPolygon, wxT( "orphans" ) );
    thermals = parseOptionalAttribute<bool>( aPolygon, wxT( "thermals" ) );
    rank     = parseOptionalAttribute<int>( aPolygon, wxT( "rank" ) );
}


EHOLE::EHOLE( wxXmlNode* aHole )
{
    /*
    <!ELEMENT hole EMPTY>
    <!ATTLIST hole
          x             %Coord;        #REQUIRED
          y             %Coord;        #REQUIRED
          drill         %Dimension;    #REQUIRED
          >
    */

    // #REQUIRED:
    x     = parseRequiredAttribute<ECOORD>( aHole, wxT( "x" ) );
    y     = parseRequiredAttribute<ECOORD>( aHole, wxT( "y" ) );
    drill = parseRequiredAttribute<ECOORD>( aHole, wxT( "drill" ) );
}


EELEMENT::EELEMENT( wxXmlNode* aElement )
{
    /*
    <!ELEMENT element (attribute*, variant*)>
    <!ATTLIST element
          name          %String;       #REQUIRED
          library       %String;       #REQUIRED
          package       %String;       #REQUIRED
          value         %String;       #REQUIRED
          x             %Coord;        #REQUIRED
          y             %Coord;        #REQUIRED
          locked        %Bool;         "no"
          smashed       %Bool;         "no"
          rot           %Rotation;     "R0"
          >
    */

    // #REQUIRED
    name    = parseRequiredAttribute<wxString>( aElement, wxT( "name" ) );
    library = parseRequiredAttribute<wxString>( aElement, wxT( "library" ) );
    value   = parseRequiredAttribute<wxString>( aElement, wxT( "value" ) );
    std::string p = parseRequiredAttribute<std::string>( aElement, wxT( "package" ) );
    ReplaceIllegalFileNameChars( &p, '_' );
    package = wxString::FromUTF8( p.c_str() );

    x       = parseRequiredAttribute<ECOORD>( aElement, wxT( "x" ) );
    y       = parseRequiredAttribute<ECOORD>( aElement, wxT( "y" ) );

    // optional
    locked  = parseOptionalAttribute<bool>( aElement, wxT( "locked" ) );
    smashed = parseOptionalAttribute<bool>( aElement, wxT( "smashed" ) );
    rot     = parseOptionalAttribute<EROT>( aElement, wxT( "rot" ) );
}


ELAYER::ELAYER( wxXmlNode* aLayer )
{
    /*
    <!ELEMENT layer EMPTY>
    <!ATTLIST layer
          number        %Layer;        #REQUIRED
          name          %String;       #REQUIRED
          color         %Int;          #REQUIRED
          fill          %Int;          #REQUIRED
          visible       %Bool;         "yes"
          active        %Bool;         "yes"
          >
    */

    number  = parseRequiredAttribute<int>( aLayer, wxT( "number" ) );
    name    = parseRequiredAttribute<wxString>( aLayer, wxT( "name" ) );
    color   = parseRequiredAttribute<int>( aLayer, wxT( "color" ) );
    fill    = 1;    // Temporary value.
    visible = parseOptionalAttribute<bool>( aLayer, wxT( "visible" ) );
    active  = parseOptionalAttribute<bool>( aLayer, wxT( "active" ) );
}


EPART::EPART( wxXmlNode* aPart )
{
    /*
     *  <!ELEMENT part (attribute*, variant*)>
     *  <!ATTLIST part
     *  name          %String;       #REQUIRED
     *  library       %String;       #REQUIRED
     *  deviceset     %String;       #REQUIRED
     *  device        %String;       #REQUIRED
     *  technology    %String;       ""
     *  value         %String;       #IMPLIED
     *  >
     */
    // #REQUIRED
    name = parseRequiredAttribute<wxString>( aPart, wxT( "name" ) );
    library = parseRequiredAttribute<wxString>( aPart, wxT( "library" ) );
    deviceset = parseRequiredAttribute<wxString>( aPart, wxT( "deviceset" ) );
    device = parseRequiredAttribute<wxString>( aPart, wxT( "device" ) );
    technology = parseOptionalAttribute<wxString>( aPart, wxT( "technology" ) );
    value = parseOptionalAttribute<wxString>( aPart, wxT( "value" ) );

    for( wxXmlNode* child = aPart->GetChildren(); child; child = child->GetNext() )
    {
        if( child->GetName() == wxT( "attribute" ) )
        {
            std::string aname, avalue;

            for( wxXmlAttribute* x = child->GetAttributes(); x; x = x->GetNext() )
            {
                if( x->GetName() == wxT( "name" ) )
                    aname = x->GetValue();
                else if( x->GetName() == wxT( "value" ) )
                    avalue = x->GetValue();
            }

            if( aname.size() && avalue.size() )
                attribute[aname] = avalue;
        }
        else if( child->GetName() == wxT( "variant" ) )
        {
            std::string aname, avalue;

            for( wxXmlAttribute* x = child->GetAttributes(); x; x = x->GetNext() )
            {
                if( x->GetName() == wxT( "name" ) )
                    aname = x->GetValue();
                else if( x->GetName() == wxT( "value" ) )
                    avalue = x->GetValue();
            }

            if( aname.size() && avalue.size() )
                variant[aname] = avalue;
        }
    }
}


EINSTANCE::EINSTANCE( wxXmlNode* aInstance )
{
    /*
     *  <!ELEMENT instance (attribute)*>
     *  <!ATTLIST instance
     *     part          %String;       #REQUIRED
     *     gate          %String;       #REQUIRED
     *     x             %Coord;        #REQUIRED
     *     y             %Coord;        #REQUIRED
     *     smashed       %Bool;         "no"
     *     rot           %Rotation;     "R0"
     *     >
     */
    part    = parseRequiredAttribute<wxString>( aInstance, wxT( "part" ) );
    gate    = parseRequiredAttribute<wxString>( aInstance, wxT( "gate" ) );

    x   = parseRequiredAttribute<ECOORD>( aInstance, wxT( "x" ) );
    y   = parseRequiredAttribute<ECOORD>( aInstance, wxT( "y" ) );

    // optional
    smashed = parseOptionalAttribute<bool>( aInstance, wxT( "smashed" ) );
    rot = parseOptionalAttribute<EROT>( aInstance, wxT( "rot" ) );
}


EGATE::EGATE( wxXmlNode* aGate )
{
    /*
     *   <!ELEMENT gate EMPTY>
     *   <!ATTLIST gate
     *   name          %String;       #REQUIRED
     *   symbol        %String;       #REQUIRED
     *   x             %Coord;        #REQUIRED
     *   y             %Coord;        #REQUIRED
     *   addlevel      %GateAddLevel; "next"
     *   swaplevel     %Int;          "0"
     *   >
     */

    name = parseRequiredAttribute<wxString>( aGate, wxT( "name" ) );
    symbol = parseRequiredAttribute<wxString>( aGate, wxT( "symbol" ) );

    x   = parseRequiredAttribute<ECOORD>( aGate, wxT( "x" ) );
    y   = parseRequiredAttribute<ECOORD>( aGate, wxT( "y" ) );

    opt_wxString stemp = parseOptionalAttribute<wxString>( aGate, wxT( "addlevel" ) );

    // (off | value | name | both)
    if( stemp == wxT( "must" ) )
        addlevel = EGATE::MUST;
    else if( stemp == wxT( "can" ) )
        addlevel = EGATE::CAN;
    else if( stemp == wxT( "next" ) )
        addlevel = EGATE::NEXT;
    else if( stemp == wxT( "request" ) )
        addlevel = EGATE::REQUEST;
    else if( stemp == wxT( "always" ) )
        addlevel = EGATE::ALWAYS;
    else
        addlevel = EGATE::NEXT;
}


ECONNECT::ECONNECT( wxXmlNode* aConnect )
{
    /*
     *  <!ELEMENT connect EMPTY>
     *  <!ATTLIST connect
     *         gate          %String;       #REQUIRED
     *         pin           %String;       #REQUIRED
     *         pad           %String;       #REQUIRED
     *         route         %ContactRoute; "all"
     *         >
     */
    gate =  parseRequiredAttribute<wxString>( aConnect, wxT( "gate" ) );
    pin =  parseRequiredAttribute<wxString>( aConnect, wxT( "pin" ) );
    pad = parseRequiredAttribute<wxString>( aConnect, wxT( "pad" ) );
}


EDEVICE::EDEVICE( wxXmlNode* aDevice )
{
    /*
        <!ELEMENT device (connects?, technologies?)>
        <!ATTLIST device
                name          %String;       ""
                package       %String;       #IMPLIED
                >
     */
    name = parseRequiredAttribute<wxString>( aDevice, wxT( "name" ) );
    opt_wxString pack = parseOptionalAttribute<wxString>( aDevice, wxT( "package" ) );

    if( pack )
    {
        std::string p( pack->c_str() );
        ReplaceIllegalFileNameChars( &p, '_' );
        package.Set( wxString::FromUTF8( p.c_str() ) );
    }

    NODE_MAP   aDeviceChildren = MapChildren( aDevice );
    wxXmlNode* connectNode = getChildrenNodes( aDeviceChildren, wxT( "connects" ) );

    while( connectNode )
    {
        connects.emplace_back( connectNode );
        connectNode = connectNode->GetNext();
    }
}


EDEVICE_SET::EDEVICE_SET( wxXmlNode* aDeviceSet )
{
    /*
      <!ELEMENT deviceset (description?, gates, devices)>
      <!ATTLIST deviceset
              name          %String;       #REQUIRED
              prefix        %String;       ""
              uservalue     %Bool;         "no"
              >
     */

    name = parseRequiredAttribute<wxString>( aDeviceSet, wxT( "name" ) );
    prefix = parseOptionalAttribute<wxString>( aDeviceSet, wxT( "prefix" ) );
    uservalue = parseOptionalAttribute<bool>( aDeviceSet, wxT( "uservalue" ) );

    /* Russell: Parsing of devices and gates moved to sch_eagle_plugin.cpp
    *
    //TODO: description

    NODE_MAP aDeviceSetChildren = MapChildren(aDeviceSet);
    wxXmlNode* deviceNode = getChildrenNodes(aDeviceSetChildren, wxT( "device" ));

    while(deviceNode){
        devices.push_back(EDEVICE(deviceNode));
        deviceNode->GetNext();
    }

    wxXmlNode* gateNode = getChildrenNodes(aDeviceSetChildren, wxT( "gate" ));

    while(gateNode){
        gates.push_back(EGATE(gateNode));
        gateNode->GetNext();
    }
    */

}


ECLASS::ECLASS( wxXmlNode* aClass )
{
    number = parseRequiredAttribute<wxString>( aClass, wxT( "number" ) );
    name   = parseRequiredAttribute<wxString>( aClass, wxT( "name" ) );

    for( wxXmlNode* child = aClass->GetChildren(); child; child = child->GetNext() )
    {
        if( child->GetName() == wxT( "clearance" ) )
        {
            wxString to = parseRequiredAttribute<wxString>( child, wxT( "class" ) );
            ECOORD value = parseRequiredAttribute<ECOORD>( child, wxT( "value" ) );

            clearanceMap[to] = value;
        }
    }
}