#include "s2s.h"

#include "stdio.h"

#include <QStringList>
#include <QTextStream>
#include <QFile>
#include <QDir>
#include <QFileInfo>
#include <QtDebug>
#include <QRegExp>
#include <qmath.h>
#include <QDomNodeList>
#include <QDomDocument>
#include <QDomElement>
#include <QSvgRenderer>
#include <QFontDatabase>
#include <QFont>
#include <QFontInfo>
#include <QResource>
#include <QImage>
#include <QPainter>
#include <QBitArray>

#include "../../src/utils/textutils.h"
#include "../../src/utils/schematicrectconstants.h"

#include <limits>

/////////////////////////////////
 
bool xLessThan(ConnectorLocation * cl1, ConnectorLocation * cl2)
{
    return cl1->terminalPoint.x() < cl2->terminalPoint.x();
}

bool yLessThan(ConnectorLocation * cl1, ConnectorLocation * cl2)
{
    return cl1->terminalPoint.y() < cl2->terminalPoint.y();
}

double getY(const QPointF & p) {
    return p.y();
}

double getX(const QPointF & p) {
    return p.x();
}

void setHiddenAux(QList<ConnectorLocation *> & allConnectorLocations, QList<ConnectorLocation *> & sideConnectorLocations, double (*get)(const QPointF &), double fudge)
{
    int i = 0;
    while (i < sideConnectorLocations.count() - 1) {
        QList<ConnectorLocation *> same;
        ConnectorLocation * basis = sideConnectorLocations.at(i);
        same << basis;
        for (int j = i + 1; j < sideConnectorLocations.count(); j++) {
            i = j;
            ConnectorLocation * next = sideConnectorLocations.at(j);
            if (qAbs(get(basis->terminalPoint )- get(next->terminalPoint)) < fudge) {
                same << next;
            }
            else {
                break;
            }
        }
        if (same.count() > 1) {
            foreach (ConnectorLocation * connectorLocation, same) {
                connectorLocation->hidden = true;
            }
            for (int ix = allConnectorLocations.count() - 1; ix >= 0; ix--) {
                ConnectorLocation * that = allConnectorLocations.at(ix);
                if (same.contains(that)) {
                    // assume the topmost is the one at the end of allConnectorLocations
                    // the rest are hidden
                    that->hidden = false;
                    sideConnectorLocations.removeOne(that);
                    int maxIndex = -1;
                    foreach (ConnectorLocation * s, same) {
                        int ix = sideConnectorLocations.indexOf(s);
                        if (ix > maxIndex) maxIndex = ix;
                    }
                    // visible one should be the topmost of the set
                    sideConnectorLocations.insert(maxIndex + 1, that);
                    break;
                }
            }
        }
    }

}

/////////////////////////////////

static QRegExp IntegerFinder("\\d+");
static const double ImageFactor = 5;
static const double FudgeDivisor = 300;
static const QRegExp VersionRegexp("[ -_][vV][\\d]+");

///////////////////////////////////////////////////////

QString makePinNumber(const ConnectorLocation * connectorLocation, double x1, double y1, double x2, double y2) {

    if (connectorLocation->id < 0) return "";
    if (connectorLocation->hidden) return "";
    if (!connectorLocation->displayPinNumber) return "";

    QString text;
    double tx = 0;
    double ty = 0;
    if (x1 == x2) {
        text += QString("<g transform='translate(%1,%2)'><g transform='rotate(%3)'>\n")
			        .arg(x2 - SchematicRectConstants::PinWidth + SchematicRectConstants::PinSmallTextVert)  
			        .arg((y2 + y1) / 2)      
			        .arg(270)
                    ;
    }
    else {
        tx = (x2 + x1) / 2;       
        ty =  y2 - SchematicRectConstants::PinWidth + SchematicRectConstants::PinSmallTextVert;      
    }

    text += QString("<text class='text' font-family=\"%8\" stroke='none' stroke-width='%6' fill='%7' font-size='%1' x='%2' y='%3' text-anchor='%4'>%5</text>\n")
					.arg(SchematicRectConstants::PinSmallTextHeight)
					.arg(tx)
					.arg(ty)
					.arg("middle")
					.arg(connectorLocation->id)
					.arg(0)  // SW(width)
					.arg(SchematicRectConstants::PinTextColor) 
                    .arg(SchematicRectConstants::FontFamily)
                    ; 

    if (x1 == x2) {
		text += "</g></g>\n";
    }


    return text;
}

QString makePinText(const ConnectorLocation * connectorLocation, double x1, double y1, double x2, double y2, bool anchorAtStart) 
{
    if (connectorLocation->hidden) return "";

    QString text;

    bool rotate = false;
    double xOffset = 0, yOffset = 0;
    if (x1 == x2) {
        rotate = true;
        yOffset = (anchorAtStart ? -SchematicRectConstants::PinTextIndent : SchematicRectConstants::PinTextIndent);
        xOffset = SchematicRectConstants::PinTextVert;
    }
    else if (y1 == y2) {
        // horizontal pin
        xOffset = (anchorAtStart ? SchematicRectConstants::PinTextIndent : -SchematicRectConstants::PinTextIndent);
        yOffset = SchematicRectConstants::PinTextVert;
    }
    else {
        return "";
    }

    if (rotate) {
		text += QString("<g transform='translate(%1,%2)'><g transform='rotate(%3)'>\n")
			.arg(x2 + xOffset)
			.arg(y2 + yOffset)
			.arg(270);
		x2 = 0;
		y2 = 0;
        xOffset = yOffset = 0;
	}

	text += QString("<text class='text' font-family=\"%8\" stroke='none' stroke-width='%6' fill='%7' font-size='%1' x='%2' y='%3' text-anchor='%4'>%5</text>\n")
						.arg(SchematicRectConstants::PinBigTextHeight)
						.arg(x2 + xOffset)
						.arg(y2 + yOffset)
						.arg(anchorAtStart ? "start" : "end")
						.arg(TextUtils::escapeAnd(connectorLocation->name))
						.arg(0)  // SW(width)
						.arg(SchematicRectConstants::PinTextColor) 
                        .arg(SchematicRectConstants::FontFamily)
                        ;  

    if (rotate) {
		text += "</g></g>\n";
	}

    return text;
}

QString makePin(const ConnectorLocation * connectorLocation, double x1, double y1, double x2, double y2) {
    return QString("<line class='pin' x1='%1' y1='%2' x2='%3' y2='%4' fill='none' stroke='%5' stroke-width='%6' stroke-linecap='round' id='%7' />\n")
            .arg(x1)
            .arg(y1)
            .arg(x2)
            .arg(y2)
            .arg(connectorLocation->hidden ? "none" : SchematicRectConstants::PinColor)
            .arg(connectorLocation->hidden ? 0 : SchematicRectConstants::PinWidth)
            .arg(connectorLocation->svgID)
            ;
}

QString makeTerminal(const ConnectorLocation * connectorLocation, double x, double y) {
    return QString("<rect class='terminal' x='%1' y='%2' width='%3' height='%4' fill='none' stroke='none' stroke-width='0' id='%5' />\n")
            .arg(x - (SchematicRectConstants::PinWidth / 2))
            .arg(y - (SchematicRectConstants::PinWidth / 2))
            .arg(SchematicRectConstants::PinWidth)
            .arg(SchematicRectConstants::PinWidth)
            .arg(connectorLocation->terminalID)
            ;
}

///////////////////////////////////////////////////////


S2S::S2S(bool fzpzStyle) : QObject()
{
    m_image = new QImage(50 * ImageFactor, 5 * ImageFactor, QImage::Format_Mono);
    m_fzpzStyle = fzpzStyle;
}

void S2S::message(const QString & msg) {
   // QTextStream cout(stdout);
  //  cout << msg;
   // cout.flush();

	qDebug() << msg;
    emit messageSignal(msg);
}

void S2S::saveFile(const QString & content, const QString & path) 
{
	QFile file(path);
	if (file.open(QIODevice::WriteOnly | QIODevice::Text)) {
		QTextStream out(&file);
		out.setCodec("UTF-8");
		out << content;
		file.close();
	}
}

bool S2S::onefzp(QString & fzpFilePath, QString & schematicFilePath) {
    if (!fzpFilePath.endsWith(".fzp")) {
        return false;
    }

    bool createSchematicFile = schematicFilePath.isEmpty();
    QString newSchematicFilePath = schematicFilePath;

    m_lefts.clear();
    m_rights.clear();
    m_tops.clear();
    m_bottoms.clear();

    QFile file(fzpFilePath);

	QString errorStr;
	int errorLine;
	int errorColumn;

	QDomDocument dom;
	if (!dom.setContent(&file, true, &errorStr, &errorLine, &errorColumn)) {
		message(tr("Failed loading '%1', %2 line:%3 col:%4").arg(fzpFilePath).arg(errorStr).arg(errorLine).arg(errorColumn));
		return false;
	}

    QDomElement root = dom.documentElement();
    QDomElement titleElement = root.firstChildElement("title");
    QString title;
    TextUtils::findText(titleElement, title);
    //int ix = VersionRegexp.lastIndexIn(title);
    //if (ix > 0 && ix + VersionRegexp.cap(0).count() == title.count()) {
    //    title.chop(VersionRegexp.cap(0).count());
    //}
    QStringList titles;
    titles << title;
    TextUtils::resplit(titles, " ");
    TextUtils::resplit(titles, "_");
    TextUtils::resplit(titles, "-");


    if (createSchematicFile) {
        QString schematicFileName;
        QDomNodeList nodeList = root.elementsByTagName("schematicView");
        for (int i = 0; i < nodeList.count(); i++) {
            QDomElement schematicView = nodeList.at(i).toElement();
            QDomElement layers = schematicView.firstChildElement("layers");
            schematicFileName = layers.attribute("image");
            if (!schematicFileName.isEmpty()) break;
        }

        if (schematicFileName.isEmpty()) {
		    message(tr("Schematic not found for '%1'").arg(fzpFilePath));
            return false;
        }

        if (m_fzpzStyle) {
             schematicFileName.replace("/", ".");
             schematicFileName = "svg." + schematicFileName;
        }

        schematicFilePath = m_oldSvgDir.absoluteFilePath(schematicFileName);
        newSchematicFilePath = m_newSvgDir.absoluteFilePath(schematicFileName);
    }

    if (!ensureTerminalPoints(fzpFilePath, schematicFilePath, root)) {
        return false;
    }

    qDebug() << schematicFilePath;

    QSvgRenderer renderer;
    bool loaded = renderer.load(schematicFilePath);
    if (!loaded) {
		message(tr("Unable to load schematic '%1' for '%2'").arg(schematicFilePath).arg(fzpFilePath));
        return false;
    }

    QList<ConnectorLocation *> connectorLocations = initConnectors(root, renderer, fzpFilePath, schematicFilePath);

    QRectF viewBox = renderer.viewBoxF();
    if (viewBox.isEmpty()) {
        qDebug() << "\tempty viewbox";
    }
    double oldUnit = lrtb(connectorLocations, viewBox);

    if (qAbs(oldUnit - SchematicRectConstants::NewUnit) < (SchematicRectConstants::NewUnit / 25)) {
		message(tr("Schematic '%1' is already using the 0.1inch standard.").arg(schematicFilePath));
        return false;
    }

    setHidden(connectorLocations);

    double minPinV = 0;
    double maxPinV = 0;
    if (m_lefts.count() && m_rights.count()) {
        minPinV = qMin(m_lefts.first()->terminalPoint.y(), m_rights.first()->terminalPoint.y());
        maxPinV = qMax(m_lefts.last()->terminalPoint.y(), m_rights.last()->terminalPoint.y());
    }
    else if (m_rights.count()) {
        minPinV = m_rights.first()->terminalPoint.y();
        maxPinV = m_rights.last()->terminalPoint.y();
    }
    else if (m_lefts.count()) {
        minPinV = m_lefts.first()->terminalPoint.y();
        maxPinV = m_lefts.last()->terminalPoint.y();
    }
    int vPinUnits = qRound((maxPinV - minPinV) / oldUnit) + 2;
    int vUnits = vPinUnits;

    double minPinH = 0;
    double maxPinH = 0;
    if (m_bottoms.count() && m_tops.count()) {
        minPinH = qMin(m_bottoms.first()->terminalPoint.x(), m_tops.first()->terminalPoint.x());
        maxPinH = qMax(m_bottoms.last()->terminalPoint.x(), m_tops.last()->terminalPoint.x());
    }
    else if (m_bottoms.count()) {
        minPinH = m_bottoms.first()->terminalPoint.x();
        maxPinH = m_bottoms.last()->terminalPoint.x();
    }
    else if (m_tops.count()) {
        minPinH = m_tops.first()->terminalPoint.x();
        maxPinH = m_tops.last()->terminalPoint.x();
    }
    int hPinUnits = qRound((maxPinH - minPinH) / oldUnit) + 2;
    int hUnits = hPinUnits;

	double hPinTextMax = 0;
	for (int i = 0; i < m_lefts.count(); i++) {
		double w = stringWidthMM(SchematicRectConstants::PinBigTextHeight, m_lefts.at(i)->name);
		if (w > hPinTextMax) hPinTextMax = w;
	}
	for (int i = 0; i < m_rights.count(); i++) {
		double w = stringWidthMM(SchematicRectConstants::PinBigTextHeight, m_rights.at(i)->name);
		if (w > hPinTextMax) hPinTextMax = w;
	}
    int leftTextUnits = qCeil(hPinTextMax / SchematicRectConstants::NewUnit);
    int rightTextUnits = leftTextUnits;


	double vTopPinTextMax = 0;
	for (int i = 0; i < m_tops.count(); i++) {
		double w = stringWidthMM(SchematicRectConstants::PinBigTextHeight, m_tops.at(i)->name);
		if (w > vTopPinTextMax) vTopPinTextMax = w;
	}
    int topTextUnits = qCeil(vTopPinTextMax / SchematicRectConstants::NewUnit);
	double vBottomPinTextMax = 0;
	for (int i = 0; i < m_bottoms.count(); i++) {
		double w = stringWidthMM(SchematicRectConstants::PinBigTextHeight, m_bottoms.at(i)->name);
		if (w > vBottomPinTextMax) vBottomPinTextMax = w;
	}
    int bottomTextUnits = qCeil(vBottomPinTextMax / SchematicRectConstants::NewUnit);

    double labelTextMax = spaceTitle(titles, hUnits - leftTextUnits - rightTextUnits - 2);

    double textWidth = hPinTextMax + hPinTextMax + labelTextMax + (6 * SchematicRectConstants::PinTextIndent);   // PTI text PTI PTI title PTI PTI text PTI           
    double hTextUnits = qCeil(textWidth / SchematicRectConstants::NewUnit);
    if (hTextUnits > hUnits) hUnits = hTextUnits;

    textWidth = titles.count() * (SchematicRectConstants::LabelTextHeight + SchematicRectConstants::LabelTextSpace);
    double vTextUnits = qCeil((textWidth / SchematicRectConstants::NewUnit) + (2 * SchematicRectConstants::PinTextIndent));
    if (vTextUnits > vUnits) vUnits = vTextUnits;

    vUnits += topTextUnits;
    vUnits += bottomTextUnits;

    double fullWidth = hUnits;
    if (m_lefts.count()) fullWidth += 2;
    if (m_rights.count()) fullWidth += 2;
    double fullHeight = vUnits;
    if (m_tops.count()) fullHeight += 2;
    if (m_bottoms.count()) fullHeight += 2;



    // construct svg

    QString svg = TextUtils::makeSVGHeader(25.4, 25.4, fullWidth * SchematicRectConstants::NewUnit, fullHeight * SchematicRectConstants::NewUnit);
    double rectL = SchematicRectConstants::RectStrokeWidth / 2;
    double rectT = rectL;
    if (m_lefts.count()) rectL += 2 * SchematicRectConstants::NewUnit;
    if (m_tops.count()) rectT += 2 * SchematicRectConstants::NewUnit;
    svg += "<g id='schematic'>\n";
    svg += QString("<rect class='interior rect' x='%1' y='%2' width='%3' height='%4' fill='%5' stroke='%6' stroke-width='%7' stroke-linecap='round' />\n")
                .arg(rectL)
                .arg(rectT)
                .arg((hUnits * SchematicRectConstants::NewUnit) - SchematicRectConstants::RectStrokeWidth)
                .arg((vUnits * SchematicRectConstants::NewUnit) - SchematicRectConstants::RectStrokeWidth)
                .arg(SchematicRectConstants::RectFillColor)
                .arg(SchematicRectConstants::RectStrokeColor)
                .arg(SchematicRectConstants::RectStrokeWidth)
                ;

    double vPinOffset = 0;
    if (m_tops.count()) vPinOffset = 2 * SchematicRectConstants::NewUnit;
    vPinOffset += topTextUnits * SchematicRectConstants::NewUnit;
    int space = vUnits - vPinUnits - topTextUnits - bottomTextUnits;
    if (space > 1) {
        vPinOffset += (space / 2) * SchematicRectConstants::NewUnit;
    }

    foreach (ConnectorLocation * connectorLocation, m_rights) {
        int units = qRound((connectorLocation->terminalPoint.y() - minPinV) / oldUnit) + 1;
        double y = units * SchematicRectConstants::NewUnit + vPinOffset;
        double x1 = ((fullWidth - 2) * SchematicRectConstants::NewUnit) - (SchematicRectConstants::PinWidth / 2);
        double x2 = (fullWidth * SchematicRectConstants::NewUnit) - (SchematicRectConstants::PinWidth / 2);
        svg += makePin(connectorLocation, x1, y, x2, y);
        svg += makePinNumber(connectorLocation, x1, y, x2, y);
        svg += makePinText(connectorLocation, x2, y, x1, y, false);
        svg += makeTerminal(connectorLocation, fullWidth * SchematicRectConstants::NewUnit, y);
    }

    foreach (ConnectorLocation * connectorLocation, m_lefts) {
        int units = qRound((connectorLocation->terminalPoint.y() - minPinV) / oldUnit) + 1;
        double y = units * SchematicRectConstants::NewUnit + vPinOffset;
        double x1 = SchematicRectConstants::PinWidth / 2;
        double x2 = (2 * SchematicRectConstants::NewUnit) + (SchematicRectConstants::PinWidth / 2);
        svg += makePin(connectorLocation, x1, y, x2, y);
        svg += makePinNumber(connectorLocation, x1, y, x2, y);
        svg += makePinText(connectorLocation, x1, y, x2, y, true);
        svg += makeTerminal(connectorLocation, 0, y);
    }

    double hPinOffset = 0;
    if (m_lefts.count()) hPinOffset = 2 * SchematicRectConstants::NewUnit;
    space = hUnits - hPinUnits;
    if (space > 1) {
        hPinOffset += (space / 2) * SchematicRectConstants::NewUnit;
    }

    foreach (ConnectorLocation * connectorLocation, m_bottoms) {
        int units = qRound((connectorLocation->terminalPoint.x() - minPinH) / oldUnit) + 1;
        double x = units * SchematicRectConstants::NewUnit + hPinOffset;
        double y1 = ((fullHeight - 2) * SchematicRectConstants::NewUnit) - (SchematicRectConstants::PinWidth / 2);
        double y2 = (fullHeight * SchematicRectConstants::NewUnit) - (SchematicRectConstants::PinWidth / 2);
        svg += makePin(connectorLocation, x, y1, x, y2);
        svg += makePinNumber(connectorLocation, x, y1, x, y2);
        svg += makePinText(connectorLocation, x, y2, x, y1, true);
        svg += makeTerminal(connectorLocation, x, fullHeight * SchematicRectConstants::NewUnit);
    }

    foreach (ConnectorLocation * connectorLocation, m_tops) {
        int units = qRound((connectorLocation->terminalPoint.x() - minPinH) / oldUnit) + 1;
        double x = units * SchematicRectConstants::NewUnit + hPinOffset;
        double y1 =  SchematicRectConstants::PinWidth / 2;
        double y2 = (2 * SchematicRectConstants::NewUnit) + (SchematicRectConstants::PinWidth / 2);
        svg += makePin(connectorLocation, x, y1, x, y2);
        svg += makePinNumber(connectorLocation, x, y1, x, y2);
        svg += makePinText(connectorLocation, x, y1, x, y2, false);
        svg += makeTerminal(connectorLocation, x, 0);
    }

    double y = vUnits * SchematicRectConstants::NewUnit / 2;
    y -= titles.count() * (SchematicRectConstants::LabelTextHeight + SchematicRectConstants::LabelTextSpace) / 2;
    y += rectT;
    y = qMax(y, rectT + (topTextUnits * SchematicRectConstants::NewUnit) + SchematicRectConstants::LabelTextHeight + SchematicRectConstants::LabelTextSpace + SchematicRectConstants::PinTextIndent);  // y seems to be the location of the baseline so add a line
    foreach (QString subTitle, titles) {
        svg += QString("<text class='text' id='label' font-family=\"%7\" stroke='none' stroke-width='%4' fill='%5' font-size='%1' x='%2' y='%3' text-anchor='middle'>%6</text>\n")
				    .arg(SchematicRectConstants::LabelTextHeight)
				    .arg(((hUnits * SchematicRectConstants::NewUnit) / 2) + rectL)
				    .arg(y)
				    .arg(0)  // SW(width)
				    .arg(SchematicRectConstants::TitleColor) 
                    .arg(TextUtils::escapeAnd(subTitle))
                    .arg(SchematicRectConstants::FontFamily)
                    ; 
            y += (SchematicRectConstants::LabelTextHeight + SchematicRectConstants::LabelTextSpace);
        }


    svg +="</g>\n";
    svg +="</svg>\n";

    TextUtils::writeUtf8(newSchematicFilePath, svg);
    qDebug() << newSchematicFilePath;
    qDebug() << "";
    return true;
}


double S2S::stringWidthMM(double fontSize, const QString & string) {

    /*
    // tried using FontMetrics but the result is always too short
    QFont font("Droid Sans");
	font.setPointSizeF(fontSize * 72 / 25.4);
	QFontMetricsF fontMetrics(font);
    double pixels = fontMetrics.width(string);
    double mm = 25.4 * pixels / 90;
    */

    QString svg = TextUtils::makeSVGHeader(25.4, 25.4, 50, 5);
    svg += QString("<text font=\"%1\" font-size='%2' stroke='none' stroke-width='0' fill='black' x='0' y='%4' text-anchor='start' >%3</text>")
        .arg(SchematicRectConstants::FontFamily).arg(fontSize).arg(TextUtils::escapeAnd(string)).arg(2.5);
    svg += "</svg>";

    QSvgRenderer renderer(svg.toUtf8());
    m_image->fill(0xffffffff);
	QPainter painter;
	painter.begin(m_image);
	painter.setRenderHint(QPainter::Antialiasing, false);
    painter.setRenderHint(QPainter::SmoothPixmapTransform, false);
	renderer.render(&painter);
	painter.end();
    //QDir dir(QCoreApplication::applicationDirPath());
    //dir.cdUp();
    //image.save(dir.absoluteFilePath("bloody_font.png"));
    int bestX = 0;
    for (int y = 0; y < m_image->height(); y++) {
        for (int x = bestX; x < m_image->width(); x++) {
            if (m_image->pixel(x, y) == 0xff000000) {
                bestX = x;
            }
        }
    }

    //if (mm < bestX / ImageFactor) {
    //    qDebug() << "string width" << mm << (bestX / ImageFactor) << string;
    //}

    return bestX / ImageFactor;
}

QList<ConnectorLocation *> S2S::initConnectors(const QDomElement & root, const QSvgRenderer & renderer, const QString & fzpFilename, const QString & svgFilename) 
{
    QList<ConnectorLocation *> connectorLocations;
    m_minLeft = std::numeric_limits<int>::max();
    m_minTop = std::numeric_limits<int>::max();
    m_maxRight = std::numeric_limits<int>::min();
    m_maxBottom = std::numeric_limits<int>::min();

    QDomElement connectors = root.firstChildElement("connectors");
    QDomElement connector = connectors.firstChildElement("connector");
    QBitArray idlist;
    int noIDCount = 0;
    while (!connector.isNull()) {
        QDomElement schematicView = connector.firstChildElement("views").firstChildElement("schematicView");
        QString svgID = schematicView.firstChildElement("p").attribute("svgId");
        if (svgID.isEmpty()) {
            message(tr("Missing connector %1 in '%2' schematic of '%3'").arg(connector.attribute("id")).arg(svgFilename).arg(fzpFilename));
        }
        else {
            ConnectorLocation * connectorLocation = new ConnectorLocation;
            connectorLocation->id = -1;
            connectorLocation->hidden = false;
            connectorLocation->displayPinNumber = false;
            QString id = connector.attribute("id");
            int ix = IntegerFinder.indexIn(id);
            if (ix > 0) {
                connectorLocation->id = IntegerFinder.cap(0).toInt();
                if (idlist.size() < connectorLocation->id + 1) {
                    int oldsize = idlist.size();
                    idlist.resize(connectorLocation->id + 1);
                    for (int i = oldsize; i < idlist.size(); i++) idlist.setBit(i, false);
                }
                idlist.setBit(connectorLocation->id, true);
            }
            else {
                noIDCount++;
            }
            connectorLocation->name = connector.attribute("name");
            connectorLocation->terminalID = schematicView.firstChildElement("p").attribute("terminalId");
            connectorLocation->svgID = svgID;
            QRectF bounds = renderer.boundsOnElement(svgID);
		    QMatrix m = renderer.matrixForElement(svgID);
		    connectorLocation->bounds = m.mapRect(bounds);
            connectorLocation->terminalPoint = connectorLocation->bounds.center();

            if (!connectorLocation->terminalID.isEmpty()) {
                bounds = renderer.boundsOnElement(connectorLocation->terminalID);
                m = renderer.matrixForElement(connectorLocation->terminalID);
                connectorLocation->terminalPoint = m.mapRect(bounds).center();
            }
            connectorLocations.append(connectorLocation);
            if (connectorLocation->terminalPoint.x() < m_minLeft) {
                m_minLeft = connectorLocation->terminalPoint.x();
            }
            if (connectorLocation->terminalPoint.x() > m_maxRight) {
                m_maxRight = connectorLocation->terminalPoint.x();
            }
            if (connectorLocation->terminalPoint.y() < m_minTop) {
                m_minTop = connectorLocation->terminalPoint.y();
            }
            if (connectorLocation->terminalPoint.y() > m_maxBottom) {
                m_maxBottom = connectorLocation->terminalPoint.y();
            }
        }

        connector = connector.nextSiblingElement("connector");
    }

    if (noIDCount > 0) {
        qDebug() << "no id count" << noIDCount;
    }

    bool display = true;
    if (!idlist.at(0) && !idlist.at(1)) {
        display = false;
    }
    else {
        int present = 0;
        for (int i = 0; i < idlist.size(); i++) {
            if (idlist.at(i)) present++;
        }
        display = (present >= .66 * idlist.size());
    }

    foreach (ConnectorLocation * connectorLocation, connectorLocations) {
        connectorLocation->displayPinNumber = display;
    }

    if (display && idlist.at(0)) {
        foreach (ConnectorLocation * connectorLocation, connectorLocations) {
            connectorLocation->id++;
        }
    }

    return connectorLocations;
}

double S2S::lrtb(QList<ConnectorLocation *> & connectorLocations, const QRectF & viewBox) 
{
    m_fudge = qMax(m_maxRight - m_minLeft, m_maxBottom - m_minTop) / FudgeDivisor;

    foreach (ConnectorLocation * connectorLocation, connectorLocations) {
        double d[4];
        d[0] = connectorLocation->terminalPoint.x() - viewBox.left();
        d[1] = connectorLocation->terminalPoint.y() - viewBox.top();
        d[2] = viewBox.right() - connectorLocation->terminalPoint.x();
        d[3] = viewBox.bottom() - connectorLocation->terminalPoint.y();
        int ix = 0;
        int dx = d[0];
        for (int i = 1; i < 4; i++) {
            if (d[i] < dx) {
                dx = d[i];
                ix = i;
            }
        }
        switch (ix) {
            case 0:
                m_lefts << connectorLocation;
                break;
            case 1:
                m_tops << connectorLocation;
                break;
            case 2:
                m_rights << connectorLocation;
                break;
            case 3:
                m_bottoms << connectorLocation;
                break;
            default:
                qDebug() << "shouldn't happen" << ix;
        }

    }

    qSort(m_lefts.begin(), m_lefts.end(), yLessThan);
    qSort(m_rights.begin(), m_rights.end(), yLessThan);
    qSort(m_tops.begin(), m_tops.end(), xLessThan);
    qSort(m_bottoms.begin(), m_bottoms.end(), xLessThan);

    QList<double> distances;
    for (int i = 1; i < m_lefts.count(); i++) {
        ConnectorLocation * l1 = m_lefts.at(i - 1);
        ConnectorLocation * l2 = m_lefts.at(i);
        distances << l2->terminalPoint.y() - l1->terminalPoint.y();
    }
    for (int i = 1; i < m_rights.count(); i++) {
        ConnectorLocation * l1 = m_rights.at(i - 1);
        ConnectorLocation * l2 = m_rights.at(i);
        distances << l2->terminalPoint.y() - l1->terminalPoint.y();
    }
    for (int i = 1; i < m_tops.count(); i++) {
        ConnectorLocation * l1 = m_tops.at(i - 1);
        ConnectorLocation * l2 = m_tops.at(i);
        distances << l2->terminalPoint.x() - l1->terminalPoint.x();
    }
    for (int i = 1; i < m_bottoms.count(); i++) {
        ConnectorLocation * l1 = m_bottoms.at(i - 1);
        ConnectorLocation * l2 = m_bottoms.at(i);
        distances << l2->terminalPoint.x() - l1->terminalPoint.x();
    }

    qSort(distances.begin(), distances.end());

    int totalPins = m_lefts.count() + m_rights.count() + m_bottoms.count() + m_tops.count();

    int most = 0;
    foreach (double distance, distances) {
        int d = qRound(distance / m_fudge);
        if (d > most) most = d;
    }

    QVector<int> dbins(most + 2, 0);
    foreach (double distance, distances) {
        int d = qRound(distance / m_fudge);
        dbins[d] += 1;
    }

    int biggest = dbins[1];
    int biggestIndex = 1;
    for (int i = 2; i < dbins.count(); i++) {
        if (dbins[i] > biggest) {
            biggest = dbins[i];
            biggestIndex = i;
        }
    }

    if (biggest == 0) {
        qDebug() << "\tbiggest 0" << totalPins;
    }

    double oldUnit = biggestIndex * m_fudge;

    qDebug() << QString("\tunit is roughly %1mm, bin:%2 pins:%3 fudge:%4").arg(oldUnit).arg(biggest).arg(totalPins).arg(m_fudge);
    qDebug() << QString("\tl:%1 t:%2 r:%3 b:%4").arg(m_lefts.count()).arg(m_tops.count()).arg(m_rights.count()).arg(m_bottoms.count());

    return oldUnit;
}


void S2S::setHidden(QList<ConnectorLocation *> & connectorLocations) 
{
    setHiddenAux(connectorLocations, m_lefts, getY, m_fudge);
    setHiddenAux(connectorLocations, m_rights, getY, m_fudge);
    setHiddenAux(connectorLocations, m_tops, getX, m_fudge);
    setHiddenAux(connectorLocations, m_bottoms, getX, m_fudge);
}

bool S2S::ensureTerminalPoints(const QString & fzpFilePath, const QString & svgFilePath, QDomElement & fzpRoot) {
    QList<QDomElement> missing;
    QDomElement connectors = fzpRoot.firstChildElement("connectors");
    QDomElement connector = connectors.firstChildElement("connector");
    while (!connector.isNull()) {
        QDomElement views = connector.firstChildElement("views");
        QDomElement schematicView = views.firstChildElement("schematicView");
        QDomElement p = schematicView.firstChildElement("p");
        QString terminalID = p.attribute("terminalId");
        if (terminalID.isEmpty()) {
            missing << p;
        }

        connector = connector.nextSiblingElement("connector");
    }

    if (missing.count() == 0) return true;

    QSvgRenderer renderer;
    bool loaded = renderer.load(svgFilePath);
    if (!loaded) {
		message(tr("Uunable to load schematic '%1' for '%2'").arg(svgFilePath).arg(fzpFilePath));
        return false;
    }

	QString errorStr;
	int errorLine;
	int errorColumn;

    QFile file(svgFilePath);
	QDomDocument dom;
	if (!dom.setContent(&file, true, &errorStr, &errorLine, &errorColumn)) {
		message(tr("Failed loading schematic '%1', %2 line:%3 col:%4").arg(svgFilePath).arg(errorStr).arg(errorLine).arg(errorColumn));
		return false;
	}

    QDomElement svgRoot = dom.documentElement();

    bool fzpChanged = false;
    bool svgChanged = false;

    foreach (QDomElement p, missing) {
        QDomElement connector = p.parentNode().parentNode().parentNode().toElement();
        QString name = connector.attribute("id");
        if (name.isEmpty()) {
            qDebug() << "empty name in connector";
        }
        else {
            // assumes the file is well behaved, and the terminalID isn't already in use
            QString terminalName = name + "terminal";
            p.setAttribute("terminalId", terminalName);
            fzpChanged = true;

            QDomElement terminalElement = TextUtils::findElementWithAttribute(svgRoot, "id", terminalName);
            if (terminalElement.isNull()) {
                QString svgID = p.attribute("svgId");
                QDomElement connectorElement = TextUtils::findElementWithAttribute(svgRoot, "id", svgID);
                QRectF bounds = renderer.boundsOnElement(svgID);
                QDomElement rect = svgRoot.ownerDocument().createElement("rect");
                connectorElement.parentNode().insertAfter(rect, connectorElement);
                rect.setAttribute("x", bounds.left());
                rect.setAttribute("y", bounds.top());
                rect.setAttribute("width", bounds.width());
                rect.setAttribute("height", bounds.height());
                rect.setAttribute("fill", "none");
                rect.setAttribute("stroke", "none");
                rect.setAttribute("stroke-width", 0);
                rect.setAttribute("id", terminalName);
                svgChanged = true;
            }
        }
    }

    if (svgChanged) {
        TextUtils::writeUtf8(svgFilePath, TextUtils::removeXMLEntities(dom.toString(4)));
    }
    if (fzpChanged) {
        TextUtils::writeUtf8(fzpFilePath, TextUtils::removeXMLEntities(fzpRoot.ownerDocument().toString(4)));
    }

    return true;
}

double S2S::spaceTitle(QStringList & titles, int openUnits)
{
    double labelTextMax = 0;
    foreach (QString title, titles) {
		double w = stringWidthMM(SchematicRectConstants::LabelTextHeight, title);
		if (w > labelTextMax) labelTextMax = w;
    }

    double useMax = qMax(openUnits * SchematicRectConstants::NewUnit, labelTextMax);

    bool changed = false;
    int ix = 0;
    while (ix < titles.count() - 1) {
        QString combined = titles.at(ix);
        if (!(combined.endsWith("_") || combined.endsWith("-"))) {
            combined.append(" ");
        }
        combined.append(titles.at(ix + 1));
        double w = stringWidthMM(SchematicRectConstants::LabelTextHeight, combined);
        if (w <= useMax) {
            titles[ix] = combined;
            titles.removeAt(ix + 1);
            changed = true;
            continue;
        }

        ix++;
    }

    if (!changed) return labelTextMax;
     
    labelTextMax = 0;
    foreach (QString title, titles) {
		double w = stringWidthMM(SchematicRectConstants::LabelTextHeight, title);
		if (w > labelTextMax) labelTextMax = w;
    }
    return labelTextMax;
}

void S2S::setSvgDirs(QDir & oldDir, QDir & newDir) {
    m_oldSvgDir = oldDir;
    m_newSvgDir = newDir;
}

