//mytcpsocket.h
#ifndef MYTCPSOCKET_H
#define MYTCPSOCKET_H

#include <QObject>
#include <QTcpSocket>
#include <QDebug>
#include <thread>
#include <iostream>
#include <fstream>
typedef std::vector<double> vect;
class MyTcpSocket : public QObject
{
    Q_OBJECT
public:
    explicit MyTcpSocket(QObject *parent = 0);

    void doConnect();
    std::vector<vect> Convert(QByteArray mtx, int size);
    std::vector<double> Convert(QByteArray mtx);
signals:

public slots:
    void readyRead();
    void disconnected();
private:
    QTcpSocket *socket;
    QTextStream os;
    QString data;
    //char data[];
    qint64 size, toberead;
    QByteArray newdata;
};

#endif // MYTCPSOCKET_H

//main
#include <QCoreApplication>
#include "mytcpsocket.h"

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    MyTcpSocket s;
    s.doConnect();

    return a.exec();
}

//mytcpsocket.cpp
#include "mytcpsocket.h"

MyTcpSocket::MyTcpSocket(QObject *parent) :
    QObject(parent)
{
   // Newdata = "noinfo";
}

void MyTcpSocket::doConnect()
{
    socket = new QTcpSocket(this);
    socket->connectToHost("localhost", 1234);
    if(socket->waitForConnected(5000))
    {
        qDebug()<<"Connected!";
    }
    else
    {
        qDebug()<<"Not connected!";
    }
    os.setDevice(socket);
    //os.setAutoDetectUnicode(true);
   // os.setFieldAlignment(QTextStream::AlignRight);
    //socket->write("Hello server\r\n\r\n");
    os<<"Hello, server!";
    os.flush();
    socket->waitForBytesWritten(1000);
    connect(socket, SIGNAL(readyRead()), this, SLOT(readyRead()), Qt::DirectConnection);
    connect(socket, SIGNAL(disconnected()), this, SLOT(disconnected()));


}
void MyTcpSocket::readyRead()
{
    double summ = 0;



    //os.setAutoDetectUnicode(true);

    //os<<"12345";

       // socket->write("Hello server\r\n\r\n");

while(newdata!="Job is done!")
         {


            socket->waitForReadyRead(3000);
            //toberead = socket->bytesAvailable();
            qDebug()<<"Reading: "<<socket->bytesAvailable();;
            // Newdata = socket->readAll();
            //size = socket->readLine(data, toberead);
            //for(qint64 i=0; i<toberead; i++){
            //std::cout<<data[i];
            //QString newtext(socket->readAll());
            //qDebug()<<newtext;
            //data = newtext;
            newdata = socket->readAll();
            //os>>newdata;
            if(newdata!="Job is done!")
            {
                double finalIndex = newdata.mid(newdata.indexOf("Info:")+6).toDouble();
                qDebug()<<"Final index: "<<finalIndex;
                QByteArray mtx2 = newdata.mid(newdata.indexOf("Second:")+7,newdata.indexOf("First:")-7);
                QByteArray mtx1 = newdata.mid(newdata.indexOf("First:")+6,newdata.indexOf("Info")-newdata.indexOf("First:")-6);
                //qDebug()<<mtx2;
                //qDebug()<<mtx1;
                //qDebug()<<mtx1.size()<<" "<<newdata.indexOf("First:")<<newdata.indexOf("Info");
                std::vector<vect> mtx2double = Convert(mtx2,mtx1.size());
                std::vector<double> mtx1double = Convert(mtx1);
                //qDebug()<<newdata.indexOf("Info: ");
                //qDebug()<<newdata;
                //}
                std::ofstream ofs ("test.txt", std::ofstream::app);
                for(unsigned int i=0; i<mtx2double.size(); i++)
                {
                    for(unsigned int j=0; j<mtx2double.size();j++)
                        ofs<<mtx2double[i][j]<<" ";
                    ofs<<std::endl;
                }
                std::this_thread::sleep_for(std::chrono::milliseconds(1000));
                ofs<<"counting:"<<std::endl;
                ofs<<"Index:"<<finalIndex;
                os<<"Index:"<<finalIndex;
                ofs<<"Vector:";
                os<<"Vector:";
                for(unsigned int i=0; i<mtx1double.size(); i++)
                {
                    for(unsigned int j=0; j<mtx1double.size(); j++)
                    {
                        summ+=mtx1double[j]*mtx2double[j][i];
                    }
                    //ofs<<summ<<"_";
                    os<<summ<<" ";
                    summ = 0;
                }
                ofs<<std::endl;
                os<<"\nCounted!";
                //socket->write("Counted!");
                os.flush();
                socket->waitForBytesWritten(1000);
            }
            else
            {
                os<<"Finished";
                os.flush();
                socket->waitForBytesWritten(1000);
            }
}
        qDebug()<<"Job is done!";
        socket->close();

}


std::vector<vect> MyTcpSocket::Convert(QByteArray mtx, int size)
{

    QByteArray newsign;
    int k = 0;
    std::vector<vect> newmtx;
    std::vector<double> newvec;
    for(int i=0; i<size; i++){
        for(int j=0; j<size; j++){
            newsign.append(mtx[k]);
            newvec.push_back(newsign.toDouble());
            k++;
            newsign.clear();
        }
        newmtx.push_back(newvec);
        newvec.clear();
        k++;
    }
    return newmtx;
}
std::vector<double> MyTcpSocket::Convert(QByteArray mtx)
{
    QByteArray newsign;
    std::vector<double> newvec;
    for(int i=0; i<mtx.size(); i++)
    {
        newsign.append(mtx[i]);
        newvec.push_back(newsign.toDouble());
        newsign.clear();
    }
    return newvec;
}
void MyTcpSocket::disconnected()
{
    qDebug()  << " Disconnected";


    socket->deleteLater();
    exit(0);
}