#include "mainwindow.h"
#include "ui_mainwindow.h"

#include <iostream>
#include <QMessageBox>
#include <math.h>

#include "google/protobuf/io/zero_copy_stream_impl.h"
#include "google/protobuf/text_format.h"



#define VIEW_WIDTH 6000
#define VIEW_HEIGHT 6000

MainWindow::MainWindow(QWidget *parent) :
    QMainWindow(parent),
    ui(new Ui::MainWindow)
{
    ui->setupUi(this);

    setWindowTitle(tr("SIASUN Remote Control"));

    mmyview = new MyView(ui->Map);
    mmyview->setObjectName(QStringLiteral("graphicsView"));
    mmyview->setGeometry(QRect(0, 0, 800, 530));
    mmyview->setCacheMode(mmyview->CacheBackground);

    mpscene = new QGraphicsScene;

    mpscene = new  QGraphicsScene(0,0,VIEW_WIDTH,VIEW_HEIGHT);
    mpscene->setBackgroundBrush(Qt::white);
    mmyview->setScene(mpscene);

    mmyview->centerOn(VIEW_WIDTH/2,VIEW_HEIGHT/2);

    ui->tabWidget->setCurrentIndex(0);

    mpdkp = new DialogKickPoint(&msissunmap, this);

    connect(mmyview,SIGNAL(dbclickxy(double,double)),this,SLOT(ondbclick(double,double)));
}

MainWindow::~MainWindow()
{
    delete ui;
}

void MainWindow::paintEvent(QPaintEvent * event)
{
    (void)event;
    static double foldratio = 1.0;


    double ratio = mmyview->getbeishu();
    if(fabs(ratio - foldratio)>0.000001)
    {
        foldratio = ratio;
        double fscale = 1.0/ratio;
        unsigned int i;
        for(i=0;i<mvectorPickPointItem.size();i++)
        {
            mvectorPickPointItem[i]->setScale(fscale);
        }
        for(i=0;i<mvectorMapPointItem.size();i++)
        {
            mvectorMapPointItem[i]->setScale(fscale);
        }

        for(i=0;i<(int)mvectorwidthline.size();i++)
        {
            mvectorwidthline[i]->ChangeWidth(mfLineWidth*fscale);
        }

        if(mpSelectPointItem != NULL)
        {
            mpSelectPointItem->setScale(fscale);
        }
    }


    mmyview->setScene(mpscene);

}


void MainWindow::resizeEvent(QResizeEvent *event)
{
    (void)event;
    QSize sizemain = ui->centralWidget->size();
    ui->tabWidget->setGeometry(0,0,sizemain.width(),sizemain.height());

    QSize sizemap = ui->Map->size();
    mmyview->setGeometry(0,0,sizemap.width(),sizemap.height());
}

void MainWindow::on_actionInsert_Kick_Point_triggered()
{
    mpdkp->setModal(false);
    mpdkp->show();
}

void MainWindow::on_actionSave_triggered()
{


    QString strfilepath = "/home/yuchuli/testsia.txt";
    using google::protobuf::TextFormat;
    using google::protobuf::io::FileOutputStream;
    using google::protobuf::io::ZeroCopyOutputStream;
    std::string strout;
    ZeroCopyOutputStream *output = new google::protobuf::io::StringOutputStream(&strout);//new FileOutputStream(file_descriptor);

    bool success = TextFormat::Print(msissunmap, output);
    if(success)
    {
        QFile xFile;
        xFile.setFileName(strfilepath);
        if(xFile.open(QIODevice::ReadWrite))
        {
            xFile.write(strout.data(),strout.size());
            xFile.close();
        }
        //           std::cout<<strout<<std::endl;
        //               qDebug(strout.data());
    }
    delete output;

}

void MainWindow::on_actionLoad_triggered()
{
    QString strfilepath = "/home/yuchuli/testsia.txt";

    QFile xFile;
    xFile.setFileName(strfilepath);
    QByteArray ba;
    if(xFile.open(QIODevice::ReadOnly))
    {
        ba = xFile.readAll();
        xFile.close();
    }
    else
    {
        QMessageBox::warning(this,tr("Warning"),tr("Open File Fail."),QMessageBox::YesAll);
        return;
    }

    using google::protobuf::TextFormat;
    using google::protobuf::io::FileInputStream;
    using google::protobuf::io::ZeroCopyInputStream;
    std::string strout;
    ZeroCopyInputStream *input = new google::protobuf::io::ArrayInputStream(ba.data(),ba.size());//new FileOutputStream(file_descriptor);

    iv::siasun::map xsiasun;
    bool success = TextFormat::Parse(input,&xsiasun);
    if(success)
    {
        msissunmap.CopyFrom(xsiasun);
    }
    else
    {
        QMessageBox::warning(this,tr("Warning"),tr("Load map fail."),QMessageBox::YesAll);
        delete input;
        return;
    }
    delete input;

    if(msissunmap.mutable_mkickarray()->mkick_size() == 0)
    {
        return;
    }

    iv::siasun::kickpointarray * pkickarray = msissunmap.mutable_mkickarray();

    int i;
    mlon0 = pkickarray->mutable_mkick(0)->mflon();
    mlat0 = pkickarray->mutable_mkick(0)->mflat();

    for(i=0;i<pkickarray->mkick_size();i++)
    {
        iv::siasun::kickpoint * ppoint = pkickarray->mutable_mkick(i);
        double x0,y0;
        double x,y;
        GaussProjCal(ppoint->mflon(),ppoint->mflat(),&x,&y);
        GaussProjCal(mlon0,mlat0,&x0,&y0);
        x = x - x0;
        y = y - y0;

        double ratio = mmyview->getbeishu();
        double fscale = 1.0/ratio;
        QGraphicsEllipseItem * pmainitem;
        pmainitem = new QGraphicsEllipseItem(0-mfPointSize/2.0,0*(-1)-mfPointSize/2.0,mfPointSize,mfPointSize);
        pmainitem->setBrush(Qt::blue);
        pmainitem->setPen(Qt::NoPen);
        pmainitem->setPos(VIEW_WIDTH/2 + x,VIEW_HEIGHT/2 -y);
        pmainitem->setScale(fscale);
        mpscene->addItem(pmainitem);
        mvectorPickPointItem.push_back(pmainitem);
    }


}

void MainWindow::on_actionInsert_Map_Point_triggered()
{
    if(mbInsertMapPoint == false)
    {
        ui->actionInsert_Map_Point->setText(tr("Stop Insert Map Point"));
        mbInsertMapPoint = true;
    }
    else
    {
        ui->actionInsert_Map_Point->setText(tr("Start Insert Map Point"));
        mbInsertMapPoint = false;
    }

}

void MainWindow::ondbclick(double x,double y)
{
    if(mbInsertMapPoint)
    {

        double fx,fy;
        fx = x - VIEW_WIDTH/2;
        fy = VIEW_HEIGHT/2 - y;
        double x0,y0;
        GaussProjCal(mlon0,mlat0,&x0,&y0);
        double flonx,flaty;
        flonx = fx + x0;
        flaty = fy + y0;
        double flon,flat;
        GaussProjInvCal(flonx,flaty,&flon,&flat);
        iv::siasun::waypointarray  * pwayarray  = msissunmap.mutable_mwayarray();
        if(pwayarray == NULL)
        {
            std::cout<<"way array is NULL."<<std::endl;
            iv::siasun::waypointarray * pnew = new iv::siasun::waypointarray;
            msissunmap.set_allocated_mwayarray(pnew);
            pwayarray = msissunmap.mutable_mwayarray();
        }
        iv::siasun::waypoint * pwaypoint = pwayarray->add_mwaypoint();
        pwaypoint->set_mflat(flat);
        pwaypoint->set_mflon(flon);


        double ratio = mmyview->getbeishu();
        double fscale = 1.0/ratio;
        QGraphicsEllipseItem * pmainitem;
        pmainitem = new QGraphicsEllipseItem(0-mfPointSize/2.0,0*(-1)-mfPointSize/2.0,mfPointSize,mfPointSize);
        pmainitem->setBrush(Qt::green);
        pmainitem->setPen(Qt::NoPen);
        pmainitem->setPos(x,y);
        pmainitem->setScale(fscale);

        mpscene->addItem(pmainitem);
        mvectorPickPointItem.push_back(pmainitem);
    }
    else
    {
        if(mnSelectMode == 1)
        {
            double fx,fy;
            fx = x - VIEW_WIDTH/2;
            fy = VIEW_HEIGHT/2 - y;
            double x0,y0;
            GaussProjCal(mlon0,mlat0,&x0,&y0);
            double flonx,flaty;
            flonx = fx + x0;
            flaty = fy + y0;
            double fdismin = 1000000.0;
            int index = -1;
            int i;
            double xv,yv;
            iv::siasun::kickpointarray * parray = msissunmap.mutable_mkickarray();
            for(i=0;i<parray->mkick_size();i++)
            {
                iv::siasun::kickpoint * p = parray->mutable_mkick(i);
                double p1x,p1y;
                GaussProjCal(p->mflon(),p->mflat(),&p1x,&p1y);
                double fdis = sqrt(pow(p1x-flonx,2)+pow(p1y-flaty,2));
                if(fdis<fdismin)
                {
                    fdismin = fdis;
                    index = i;
                    xv = p1x;
                    yv = p1y;

                }
                std::cout<<" fdis: "<<fdismin<<std::endl;
            }
            if(fdismin < mfNearDisLimit)
            {
                double ratio = mmyview->getbeishu();
                double fscale = 1.0/ratio;
                if(mpSelectPointItem == NULL)
                {

                    QGraphicsEllipseItem * pmainitem;
                    pmainitem = new QGraphicsEllipseItem(0-mfPointSize*2.0/2.0,0*(-1)-mfPointSize*2.0/2.0,mfPointSize*2.0,mfPointSize*2.0);
                    pmainitem->setBrush(Qt::red);
                    pmainitem->setPen(Qt::NoPen);
                    pmainitem->setPos(VIEW_WIDTH/2 + xv-x0,VIEW_HEIGHT/2 -(yv-y0));
                    pmainitem->setScale(fscale);
                    mpscene->addItem(pmainitem);
                    mpSelectPointItem = pmainitem;
                }
                else
                {
                    mpSelectPointItem->setPos(VIEW_WIDTH/2 + xv-x0,VIEW_HEIGHT/2 -(yv-y0));
                    mpSelectPointItem->setScale(fscale);
                }
            }
        }
    }
}

void MainWindow::on_actionCreate_Map_triggered()
{
    iv::siasun::waypointarray  * pwayarray  = msissunmap.mutable_mwayarray();
    if(pwayarray == NULL)
    {
        QMessageBox::warning(this,tr("Warning"),tr("No Way Point."),QMessageBox::YesAll);
        return;
    }
    if(pwayarray->mwaypoint_size()<2)
    {
        QMessageBox::warning(this,tr("Warning"),tr("At Least 2 point."),QMessageBox::YesAll);
        return;
    }

    mvectorlinemap.clear();
    int i;
    for(i=0;i<(int)mvectorwidthline.size();i++)
    {
        mpscene->removeItem(mvectorwidthline[i]->GetWidthLine());
        delete mvectorwidthline[i];
    }
    mvectorwidthline.clear();

    sissunmap xsissunmap;
    mvectorlinemap = xsissunmap.GetMapLine(&msissunmap);


    double x0,y0;
    GaussProjCal(mlon0,mlat0,&x0,&y0);
    for(i=0;i<(int)mvectorlinemap.size();i++)
    {
        widthline *pline = new widthline(mvectorlinemap[i].mfx1-x0,mvectorlinemap[i].mfy1-y0,
                                         mvectorlinemap[i].mfx2-x0,mvectorlinemap[i].mfy2-y0,mfLineWidth,mColorBrush_mapline,VIEW_WIDTH/2,VIEW_HEIGHT/2);
        mpscene->addItem(pline->GetWidthLine());
        double ratio = mmyview->getbeishu();
        double fscale = 1.0/ratio;
        pline->ChangeWidth(fscale*mfLineWidth);
        mvectorwidthline.push_back(pline);

    }



}

void MainWindow::on_actionSelect_None_triggered()
{
    mnSelectMode = 0;
    if(mpSelectPointItem != NULL)
    {
        mpscene->removeItem(mpSelectPointItem);
        mpSelectPointItem = NULL;
    }
}

void MainWindow::on_actionSelect_Kick_triggered()
{
   mnSelectMode = 1;
}

void MainWindow::on_actionSelect_Point_triggered()
{
    mnSelectMode = 2;
}