#include "mainwindow.h"
#include "ui_mainwindow.h"
#include <QMessageBox>
#include <QGraphicsSceneMouseEvent>
#include <iostream>
#include <QGraphicsSceneEvent>
#include <QtGui/QKeyEvent>
#include <QtGui/QMouseEvent>
#include "sowing.h"


using namespace std;

int fieldSize = 40;     //moet een deler van 400 zijn, anders grid niet juist geplaatst


QImage prent = QImage(fieldSize, fieldSize, QImage::Format_Mono);
bool grid = true;

MainWindow::MainWindow(QWidget *parent) :  //Startfunctie, opent venster
    QMainWindow(parent),
    ui(new Ui::MainWindow)
{
    ui->setupUi(this);
    createScene();
}

MainWindow::~MainWindow()       //sluit alles
{

    delete ui;
}

void MainWindow::toggleGrid() //Deze functie zorgt ervoor dat de grid op/af staat (boolean true/false)
{

    if(grid == false)
    {
        grid=true;
    }
    else grid=false;
    drawImage(prent);
}

void MainWindow::drawImage(QImage prent)    //Zal de QImage (de matrix die de info van de prent bevat) tekenen
{
    QImage prentG=prent.convertToFormat( QImage::Format_RGB32);
    prentG=prentG.scaled(400, 400, Qt::KeepAspectRatio, Qt::FastTransformation);    //vergroot de tekening naar de grootte van het visuele tekenvlak)
    //QImage tetten = QImage(fieldSize, fieldSize, QImage::Format_Mono);
    //tetten.setPixel(fieldSize/2,10,qRgb(122, 163, 39));

    if(grid == true)        //tekent het fijne grid
    {
        for (int i=0; i<400; i+=400/fieldSize)
            for(int j=0; j<400; j++)
            {
             prentG.setPixel(i, j, qRgb(122, 163, 39));
             prentG.setPixel(200, j, qRgb(122, 163, 39));
             prentG.setPixel(j, i, qRgb(122, 163, 39));
             prentG.setPixel(j, 200, qRgb(122, 163, 39));
            }
    }

    for(int j=0; j<400; j++)        // tekent de middellijnen (coarse grid)
    {
         prentG.setPixel(199, j, qRgb(122, 163, 39));
         prentG.setPixel(200, j, qRgb(122, 163, 39));
         prentG.setPixel(j, 199, qRgb(122, 163, 39));
         prentG.setPixel(j, 200, qRgb(122, 163, 39));
    }

    QPixmap image = QPixmap::fromImage(prentG); //Omzetten naar pixmap om te kunnen afdrukken

    ui->graphfield->scene()->addPixmap(image);           //voeg pixmap toe aan scene
    //cout << "Getekend" << endl;

}

void MainWindow::setClearImage()        //Cleart het tekenvlak
{
    prent.fill(1);      //Maakt bitmap helemaal wit
    drawImage(prent);

}

void MainWindow::openAbout()            //Opent een basic 'about' venster
{
    QMessageBox msgAbout;
    msgAbout.setWindowTitle("About");
    msgAbout.setText("Sowing Robot GUI");
    msgAbout.exec();

}


void MainWindow::createScene()          //Creeert een QGraphicsScene, zodat de bitmap getekend kan worden
{
   ui->graphfield->setScene(new QGraphicsScene());          //Scene creeren
        //Bitmap aanmaken

    prent.fill(1);      //Maakt bitmap helemaal wit

   drawImage(prent);


    if(ui->graphfield->scene()==0)
    {
           cout << "GEEN SCENE GELADEN" << endl;
    }
    //else cout << "SCENE LADEN GELUKT" << endl;



}

void MainWindow::kleurPixel(int i, int j) //Zal de pixel zwart/wit kleuren als erop gklikt wordt met muis
//Mousposcoordinaten meegeven

    /******************************************************************************************************************************************

    Het volgende stukje code is gefoefel en zeker niet proper geprogrammeerd.
    Eigenlijk moet er een nieuwe class aangemaakt worden voor de graphicsview, zodat de lokale coordinaten waar geklikt is kan doorgeven
    naar de scene als sceneevent.

    Hier wordt gekeken waar er geklikt werd in het globale venster, dan omgezet naar het juiste coordinaten systeem en gekeken of de coordinaat
    wel degelijk binnen het tekenvenster zitt.

    ******************************************************************************************************************************************/
{
    i=(i-40)/10;                            //Globale coordinaten transformeren naar scene coordinaten
    j=(j-40)/10-3;
    i=i*fieldSize;
    j=j*fieldSize;
    i=i/40;
    j=j/40;
if (i<fieldSize && i>=0)                    //Enkel iets dien als er binnen het tekenveld werd geklikt
    {
        if (j<fieldSize && j>=0)
        {
            switch (prent.pixelIndex(i, j))
            {
                case 0: prent.setPixel(i, j, 1); break;     //kleur pixel zwart als hij wit was
                case 1: prent.setPixel(i, j, 0); break;     //kleur pixel wit als hij zwart was
                default: cout << "Error pixel verkleuren Pixelwaatrde:"<< prent.pixelIndex(i, j) << endl; break;
            }

        }
        //else cout << "y out of bounds" << endl;
    }
    //else cout << "x out of bounds" << endl;
    drawImage(prent);               //Update de scene
}

void MainWindow::invertImage()      //inverteerd de tekening, zwarte pixel wordt wit en omgekeerd
{

   for(int i=0; i<fieldSize; i++)
   {
        for(int j=0; j<fieldSize; j++)
        {

            switch (prent.pixelIndex(QPoint(i, j)))
            {
                case 0: prent.setPixel(i, j, 1); break;
                case 1: prent.setPixel(i, j, 0); break;
                default: cout << "Error pixeldata ophalen, geeft "<< prent.pixelIndex(QPoint(i, j)) << endl; break;
            }
        }
   }
   drawImage(prent);
}

void MainWindow::drawSmiley()       //Tekent een smilie op het tekenveld
{
   int m=13;

      //Achtergrond
      prent.fill(1);      //Maakt bitmap helemaal wit

      //Ogen
      prent.setPixel(m+4, m+3, 0);
      prent.setPixel(m+9, m+3, 0);

      //Mond
      prent.setPixel(m+4, m+8, 0);
      prent.setPixel(m+3, m+7, 0);
      prent.setPixel(m+9, m+8, 0);
      prent.setPixel(m+10, m+7, 0);
      for(int i=(m+5); i<=(m+8); i++)
      {
           prent.setPixel(i, m+9, 0);
      }

      //ring erond
      for(int i=(m+3); i<=(m+10); i++)
      {
           prent.setPixel(i, m+11, 0);
           prent.setPixel(i, m, 0);
      }

      for(int j=(m+3); j<=(m+8); j++)
      {
           prent.setPixel(m, j, 0);
           prent.setPixel(m+13, j, 0);
      }
      prent.setPixel(m+2, m+1, 0);
      prent.setPixel(m+2, m+10, 0);
      prent.setPixel(m+1, m+2, 0);
      prent.setPixel(m+1, m+9, 0);
      prent.setPixel(m+11, m+1, 0);
      prent.setPixel(m+11, m+10, 0);
      prent.setPixel(m+12, m+2, 0);
      prent.setPixel(m+12, m+9, 0);

   drawImage(prent);

   //cout << "Smiley" << endl;
}

void MainWindow::mousePressEvent(QMouseEvent *ev)   //kijkt waar geklikt is en stuurt deze coordinaat door naar kleurpixel
{

 QPointF mousepos = ev->pos();
 //cout << "x pos geklikt "<< mousepos.rx() << endl;
 //cout << "y pos geklikt "<< mousepos.ry() << endl;
 kleurPixel(mousepos.rx(),mousepos.ry());
}

void MainWindow::keyPressEvent(QKeyEvent *e)    //komt in acttie als een toets gedrukt wordt
{
        if (e->key() == Qt::Key_Escape)         //sluit programma als esc gedrukt wordtt
            close();
}

//Spiegelfuncties

void MainWindow::mirrorYud()    //Spiegelt bovenste helft naar onder
{

        for (int i=0; i<fieldSize; i++)
        {
            for (int j=0; j<fieldSize/2; j++)
            {
                int p = prent.pixelIndex(QPoint(i, j));
                prent.setPixel(i, fieldSize-j-1, p);
            }
        }

     drawImage(prent);
}

void MainWindow::mirrorYdu()    //Spiegelt onderste helft naar boven
{

    for (int i=0; i<fieldSize; i++)
    {
        for (int j=fieldSize/2; j<fieldSize; j++)
        {
            int p = prent.pixelIndex(QPoint(i, j));
            prent.setPixel(i, fieldSize-j-1, p);
        }
    }

 drawImage(prent);
}

void MainWindow::mirrorXlr()       //Spiegelt linker helft naar rechts
{

        for (int j=0; j<fieldSize; j++)
        {
            for (int i=0; i<fieldSize/2; i++)
            {
                int p = prent.pixelIndex(QPoint(i, j));
                prent.setPixel(fieldSize-i-1, j, p);
            }
        }

     drawImage(prent);
}

void MainWindow::mirrorXrl()        //Spiegelt rechter helft naar links
{

        for (int j=0; j<fieldSize; j++)
        {
            for (int i=fieldSize/2; i<fieldSize; i++)
            {
                int p = prent.pixelIndex(QPoint(i, j));
                prent.setPixel(fieldSize-i-1, j, p);
            }
        }

     drawImage(prent);
}

void MainWindow::sow()      //Voert 'sowing' uit -> nieuw venster
{
    Sowing s(prent);
    s.exec();
}
