#include "Diagram.h"
#include "ui_Diagram.h"

Diagram::Diagram(QWidget *parent) :
    QWidget(parent),
    ui(new Ui::Diagram)
{
    ui->setupUi(this);
    m_parent = parent;


    QFile file(":/qss/Diagram.qss");
    file.open(QFile::ReadOnly);
    QTextStream filetext(&file);
    QString stylesheet = filetext.readAll();
    this->setStyleSheet(stylesheet);
    file.close();
    int w = 60;
    int h = 25;

    attChart = new Chart(ui->frame_Attitude);
    gyroChart = new Chart(ui->frame_Gyro);
    accChart = new Chart(ui->frame_Accelerate);

    attChart->chart()->legend()->setAlignment(Qt::AlignRight);
    gyroChart->chart()->legend()->setAlignment(Qt::AlignRight);
    accChart->chart()->legend()->setAlignment(Qt::AlignRight);

    attChart->setOperation(false);
    gyroChart->setOperation(false);
    accChart->setOperation(false);

    attChart->setRenderHint(QPainter::Antialiasing);
    gyroChart->setRenderHint(QPainter::Antialiasing);
    accChart->setRenderHint(QPainter::Antialiasing);

    //ui->label->setFixedSize(w,h);




}

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

void Diagram::setColor(QWidget *w,state s)
{
    w->setProperty("state",s);
    w->style()->unpolish(w);
    w->style()->polish(w);
}

void Diagram::setValue(QLabel *w,QString s)
{
    w->setText(s);
}



void Diagram::resizeEvent(QResizeEvent *event)
{

    attChart->setGeometry(0,0,ui->frame_Attitude->width(),ui->frame_Attitude->height());
    gyroChart->setGeometry(0,0,ui->frame_Gyro->width(),ui->frame_Gyro->height());
    accChart->setGeometry(0,0,ui->frame_Accelerate->width(),ui->frame_Accelerate->height());

}

void Diagram::closeEvent(QCloseEvent *event)
{
    setFloat();
    event->ignore();
}

void Diagram::contextMenuEvent(QContextMenuEvent *event)
{
    /*
    QMenu *menu = new QMenu(this);

    QAction *pAction = new QAction("float",this);

    connect(pAction,SIGNAL(triggered(bool)),
            this,SLOT(setFloat()));

     menu->addAction(pAction);
     menu->move(cursor().pos());
     menu->show();
     */
}


void Diagram::setFloat(void)
{
    if(this->parent())
    {
        this->setParent(nullptr);
        QScreen *screen=QGuiApplication::primaryScreen ();;
        this->move((screen->availableGeometry().width()-this->width())/2,(screen->availableGeometry().height()-this->height())/2);
        this->show();
    }
    else
    {
        this->setParent(m_parent);
        this->move(0,0);
        this->hide();
        //qDebug() << m_parent->children();

    }
}



void Diagram::setBaseState(uint32_t pos,QVariant measure,QVariant target)
{
    switch (pos) {
    case 1:
        ui->label_measure_atteck->setText(measure.toString());
        //ui->label_target_cas->setText(target.toString());
        break;
    case 2:
        ui->label_measure_slide->setText(measure.toString());
        //ui->label_target_cas->setText(target.toString());
        break;
    case 3:
        ui->label_measure_roll->setText(measure.toString());
        ui->label_target_roll->setText(target.toString());

        if(qAbs(measure.toFloat()) >= 90)
        {
            setColor(ui->label_measure_roll,state::failure);
        }
        else
        {
            setColor(ui->label_measure_roll,state::inital);
        }


        break;
    case 4:
        ui->label_measure_pitch->setText(measure.toString());
        ui->label_target_pitch->setText(target.toString());

        if(qAbs(measure.toFloat()) >= 40)
        {
            setColor(ui->label_measure_pitch,state::failure);
        }
        else
        {
            setColor(ui->label_measure_pitch,state::inital);
        }

        break;
    case 5:
        ui->label_measure_heading->setText(measure.toString());
        ui->label_target_heading->setText(target.toString());
        break;
    case 6:
        ui->label_measure_altitude->setText(measure.toString());
        ui->label_target_altitude->setText(target.toString());
        break;
    case 7:
        ui->label_measure_tas->setText(measure.toString());
        ui->label_target_tas->setText(target.toString());

        if(qAbs(measure.toFloat()) <= 100)
        {
            setColor(ui->label_measure_tas,state::failure);
        }
        else
        {
            setColor(ui->label_measure_tas,state::inital);
        }

        break;
    case 8:
        ui->label_measure_cas->setText(measure.toString());
        //ui->label_target_cas->setText(target.toString());

        if(qAbs(measure.toFloat()) <= 90)
        {
            setColor(ui->label_measure_cas,state::failure);
        }
        else
        {
            setColor(ui->label_measure_cas,state::inital);
        }

        break;
    case 9:
        ui->label_measure_gs->setText(measure.toString());
        //ui->label_target_cas->setText(target.toString());
        break;
    case 10:
        ui->label_measure_ma->setText(measure.toString());
        //ui->label_target_cas->setText(target.toString());
        break;
    case 11:
        ui->label_measure_vrate->setText(measure.toString());
        //ui->label_target_cas->setText(target.toString());

        if(measure.toFloat() <= -80)
        {
            setColor(ui->label_measure_vrate,state::failure);
        }
        else
        {
            setColor(ui->label_measure_vrate,state::inital);
        }

        break;
    }
}

void Diagram::setServo(uint32_t pos,QVariant measure,QVariant target)
{
    switch (pos) {
    case 1:
        ui->label_measure_LA->setText(measure.toString());
        ui->label_target_LA->setText(target.toString());
        break;
    case 2:
        ui->label_measure_RA->setText(measure.toString());
        ui->label_target_RA->setText(target.toString());
        break;
    case 3:
        ui->label_measure_LE->setText(measure.toString());
        ui->label_target_LE->setText(target.toString());
        break;
    case 4:
        ui->labeL_measure_RE->setText(measure.toString());
        ui->label_target_RE->setText(target.toString());
        break;
    case 5:
        ui->label_measure_RUD->setText(measure.toString());
        ui->label_target_RUD->setText(target.toString());
        break;
    }
}

void Diagram::setEngine(uint32_t pos,QVariant value)
{
    switch (pos) {
    case 1:
        ui->label_throttle->setText(value.toString());
        break;
    case 2:
        ui->label_rpm->setText(value.toString());

        if(value.toFloat() >= 46000)
        {
            setColor(ui->label_rpm,state::failure);
        }
        else
        {
            setColor(ui->label_rpm,state::inital);
        }
        break;
    case 3:
        ui->label_FuelPressure->setText(value.toString());
        break;
    case 4:
        ui->label_Innage->setText(value.toString());

        if(value.toFloat() <= 10)
        {
            setColor(ui->label_Innage,state::failure);
        }
        else
        {
            setColor(ui->label_Innage,state::inital);
        }

        break;
    case 5:
        ui->label_temp_up->setText(value.toString());

        if(value.toFloat() >= 150)
        {
            setColor(ui->label_temp_up,state::failure);
        }
        else
        {
            setColor(ui->label_temp_up,state::inital);
        }

        break;
    case 6:
        ui->label_temp_right->setText(value.toString());

        if(value.toFloat() >= 150)
        {
            setColor(ui->label_temp_right,state::failure);
        }
        else
        {
            setColor(ui->label_temp_right,state::inital);
        }

        break;

    }
}

void Diagram::setBattery(uint32_t pos,QVariant value)
{
    switch (pos) {
    case 1:
        ui->label_28V_V->setText(value.toString());

        if(qAbs(value.toFloat()) <= 23)
        {
            setColor(ui->label_28V_percent,state::failure);
            setColor(ui->label_28V_V,state::failure);
        }
        else if(qAbs(value.toFloat()) <= 25)
        {
            setColor(ui->label_28V_percent,state::warning);
            setColor(ui->label_28V_V,state::warning);
        }
        else
        {
            setColor(ui->label_28V_percent,state::inital);
            setColor(ui->label_28V_V,state::inital);
        }

        break;
    case 2:
        ui->label_28V_A->setText(value.toString());

        if(qAbs(value.toFloat()) >= 10)
        {
            setColor(ui->label_28V_A,state::failure);
        }
        else
        {
            setColor(ui->label_28V_A,state::inital);
        }

        break;
    case 3:
        ui->label_28V_percent->setText(value.toString());
        break;
    case 4:
        ui->label_56V_V->setText(value.toString());

        if(qAbs(value.toFloat()) <= 46)
        {
            setColor(ui->label_56V_percent,state::failure);
            setColor(ui->label_56V_V,state::failure);
        }
        else if(qAbs(value.toFloat()) <= 50)
        {
            setColor(ui->label_56V_percent,state::warning);
            setColor(ui->label_56V_V,state::warning);
        }
        else
        {
            setColor(ui->label_56V_percent,state::inital);
            setColor(ui->label_56V_V,state::inital);
        }

        break;
    case 5:
        ui->label_56V_A->setText(value.toString());

        if(qAbs(value.toFloat()) >= 10)
        {
            setColor(ui->label_56V_A,state::failure);
        }
        else
        {
            setColor(ui->label_56V_A,state::inital);
        }

        break;
    case 6:
        ui->label_56V_percent->setText(value.toString());
        break;
    }
}


void Diagram::setDlink(uint32_t pos,QVariant value)
{
    switch (pos) {
    case 1:
        ui->label_RSSI->setText(value.toString());

        if(qAbs(value.toFloat()) <= 50)
        {
            setColor(ui->label_RSSI,state::failure);
        }
        else
        {
            setColor(ui->label_RSSI,state::inital);
        }

        break;
    case 2:
        ui->label_RSS->setText(value.toString());

        if(qAbs(value.toFloat()) <= 500)
        {
            setColor(ui->label_RSS,state::failure);
        }
        else
        {
            setColor(ui->label_RSS,state::inital);
        }

        break;

    }
}

void Diagram::setTime(uint32_t pos,QTime Value)
{
    switch (pos) {
    case 3:
        ui->label_StartUpTime->setText(Value.toString("HH:mm:ss"));
        break;
    case 4:
        ui->label_FilghtTime->setText(Value.toString("HH:mm:ss"));
        break;
    }
}


void Diagram::setTargetPoint(int Value)
{
    ui->label_TargetPoint->setText(QString::number(Value,'f',0));
}

void Diagram::setNavigation(uint32_t pos,QVariant value)
{
    switch (pos) {
    case 1:
        ui->label_Fix->setText(value.toString());

        if(value.toString() == tr("未定位"))
        {
            setColor(ui->label_Fix,state::failure);
        }
        else if(value.toString() == tr("2D"))
        {
            setColor(ui->label_Fix,state::warning);
        }
        else
        {
            setColor(ui->label_Fix,state::inital);
        }


        break;
    case 2:
        ui->label_SVN->setText(value.toString());
        break;
    case 3:
        ui->label_Source->setText(value.toString());
        break;
    case 4:
        //ui->label_TargetPoint->setText(value.toString());
        break;
    case 5:
        ui->label_xtrack->setText(value.toString());


        if(qAbs(value.toFloat()) >= 10000)
        {
            setColor(ui->label_xtrack,state::failure);
        }
        else
        {
            setColor(ui->label_xtrack,state::inital);
        }

        break;
    case 6:
        ui->label_dist->setText(value.toString());
        break;
    }
}

void Diagram::setControlState(uint32_t pos,QVariant value)
{
    switch (pos) {
    case 1:
        ui->label_ControlMode->setText(value.toString());
        break;
    case 2:
        ui->label_FlightMode->setText(value.toString());
        break;
    case 3:
        ui->label_VMode->setText(value.toString());
        break;
    case 4:
        ui->label_HMode->setText(value.toString());
        break;
    }
}

void Diagram::setAttitude(uint8_t source,
                          float ax,float ay,float az,
                          float p,float q,float r,
                          float rol,float pit,float yaw)
{
    switch (source) {
    case 1:
    {
        if(ui->checkBox_INS->isChecked())
        {
            accChart->setSerieData(tr("INS ax"),ax);
            accChart->setSerieData(tr("INS ay"),ay);
            accChart->setSerieData(tr("INS az"),az);

            gyroChart->setSerieData(tr("INS p"),p);
            gyroChart->setSerieData(tr("INS q"),q);
            gyroChart->setSerieData(tr("INS r"),r);

            attChart->setSerieData(tr("INS roll"),rol);
            attChart->setSerieData(tr("INS pitch"),pit);
        }
    }break;
    case 2:
    {
        if(ui->checkBox_SBG->isChecked())
        {
            accChart->setSerieData(tr("SBG ax"),ax);
            accChart->setSerieData(tr("SBG ay"),ay);
            accChart->setSerieData(tr("SBG az"),az);

            gyroChart->setSerieData(tr("SBG p"),p);
            gyroChart->setSerieData(tr("SBG q"),q);
            gyroChart->setSerieData(tr("SBG r"),r);

            attChart->setSerieData(tr("SBG roll"),rol);
            attChart->setSerieData(tr("SBG pitch"),pit);
        }

    }break;
    }
}



void Diagram::on_checkBox_INS_stateChanged(int arg1)
{
    if(arg1 == Qt::Checked)
    {
        attChart->addSeries(tr("INS roll"),Qt::darkRed,Qt::SolidLine);
        attChart->addSeries(tr("INS pitch"),Qt::darkGreen,Qt::SolidLine);

        gyroChart->addSeries(tr("INS p"),Qt::darkRed,Qt::SolidLine);
        gyroChart->addSeries(tr("INS q"),Qt::darkGreen,Qt::SolidLine);
        gyroChart->addSeries(tr("INS r"),Qt::darkBlue,Qt::SolidLine);

        accChart->addSeries(tr("INS ax"),Qt::darkRed,Qt::SolidLine);
        accChart->addSeries(tr("INS ay"),Qt::darkGreen,Qt::SolidLine);
        accChart->addSeries(tr("INS az"),Qt::darkBlue,Qt::SolidLine);
    }
    else  if(arg1 == Qt::Unchecked)
    {
        attChart->removeSerie(tr("INS roll"));
        attChart->removeSerie(tr("INS pitch"));

        gyroChart->removeSerie(tr("INS p"));
        gyroChart->removeSerie(tr("INS q"));
        gyroChart->removeSerie(tr("INS r"));

        accChart->removeSerie(tr("INS ax"));
        accChart->removeSerie(tr("INS ay"));
        accChart->removeSerie(tr("INS az"));
    }
}

void Diagram::on_checkBox_SBG_stateChanged(int arg1)
{
    if(arg1 == Qt::Checked)
    {
        attChart->addSeries(tr("SBG roll"),Qt::red,Qt::DashLine);
        attChart->addSeries(tr("SBG pitch"),Qt::green,Qt::DashLine);

        gyroChart->addSeries(tr("SBG p"),Qt::red,Qt::DashLine);
        gyroChart->addSeries(tr("SBG q"),Qt::green,Qt::DashLine);
        gyroChart->addSeries(tr("SBG r"),Qt::blue,Qt::DashLine);

        accChart->addSeries(tr("SBG ax"),Qt::red,Qt::DashLine);
        accChart->addSeries(tr("SBG ay"),Qt::green,Qt::DashLine);
        accChart->addSeries(tr("SBG az"),Qt::blue,Qt::DashLine);
    }
    else  if(arg1 == Qt::Unchecked)
    {
        attChart->removeSerie(tr("SBG roll"));
        attChart->removeSerie(tr("SBG pitch"));

        gyroChart->removeSerie(tr("SBG p"));
        gyroChart->removeSerie(tr("SBG q"));
        gyroChart->removeSerie(tr("SBG r"));

        accChart->removeSerie(tr("SBG ax"));
        accChart->removeSerie(tr("SBG ay"));
        accChart->removeSerie(tr("SBG az"));
    }
}