#include "SimpleControl.h"
#include "Json.h"
#include <QFile>
#include "Config.h"
#include "Push.h"
#include "Record.h"
#include "RPC.h"
#include "Carousel.h"

SimpleControl::SimpleControl(QObject *parent) : QObject(parent)
{
    tcpSocket=NULL;
    udpPort=0;
}

void SimpleControl::init()
{
    connect(&tcp,SIGNAL(newConnection()),this,SLOT(onNewConnection()));
    connect(&udp,SIGNAL(readyRead()),this,SLOT(onUdpRead()));
    connect(&uart,SIGNAL(readyRead()),this,SLOT(onUartRead()));

    QFile file("/link/config/misc/simpleControl.json");
    file.open(QFile::ReadOnly);
    QString json=file.readAll();
    file.close();
    update(json);
}

QString SimpleControl::onRead(QString buf)
{
    QString cmd=buf;
    QStringList args;
    if(buf.contains(argSplit))
    {
        args=buf.split(argSplit);
        cmd=args.takeFirst();
    }
    qDebug()<<"Ctrl:"<<cmd<<args;

    QVariantMap map;
    foreach (QVariant obj, cmdList) {
        if(obj.toMap()["cmd"].toString()==cmd)
        {
            map=obj.toMap();
            break;
        }
    }

    if(map.isEmpty())
    {
        QString err="ERROR: Unknow CMD "+cmd;
        qDebug()<<err;
        write(err);
        return err;
    }

    if(args.isEmpty() && !map["defArgs"].toString().isEmpty())
    {
        args=map["defArgs"].toString().split(argSplit);
    }

    QString ret;
    QMetaObject::invokeMethod(this,map["func"].toString().toLatin1().data(),Qt::DirectConnection,Q_RETURN_ARG(QString,ret),Q_ARG(QStringList, args));
    write(ret);
    return ret;
}

void SimpleControl::write(QString str)
{
    str+=endCode;

    if(uart.isOpen())
    {
        uart.write(str.toUtf8().data());
        uart.flush();
    }

    if(udpPort!=0)
    {
        udp.writeDatagram(str.toUtf8(),udpIP,udpPort);
        udp.flush();
    }

    if(tcpSocket!=NULL)
    {
        tcpSocket->write(str.toUtf8());
        tcpSocket->flush();
    }
}

void SimpleControl::onTcpRead()
{
    while(tcpSocket->bytesAvailable()>0)
    {
        tcpBuf+=QString::fromUtf8(tcpSocket->readAll());
        if(tcpBuf.contains(endCode))
        {
            int i=tcpBuf.indexOf(endCode);
            onRead(tcpBuf.left(i));
            tcpBuf=tcpBuf.remove(0,i+endCode.length());
        }
    }
}

void SimpleControl::onUdpRead()
{
    while (udp.hasPendingDatagrams()) {
        QByteArray ba;
        ba.resize(udp.pendingDatagramSize());
        udp.readDatagram(ba.data(),ba.size(),&udpIP,&udpPort);
        QString str=QString::fromUtf8(ba);
        if(str.endsWith(endCode))
        {
            str=str.remove(endCode);
            onRead(str);
        }
    }
}

void SimpleControl::onUartRead()
{
    while(uart.bytesAvailable()>0)
    {
        uartBuf+=QString::fromUtf8(uart.readAll());
        if(uartBuf.contains(endCode))
        {
            int i=uartBuf.indexOf(endCode);
            onRead(uartBuf.left(i));
            uartBuf=uartBuf.remove(0,i+endCode.length());
        }
    }
}

void SimpleControl::onNewConnection()
{
    tcpSocket=tcp.nextPendingConnection();
    connect(tcpSocket,SIGNAL(readyRead()),this,SLOT(onTcpRead()));
}

bool SimpleControl::update(QString json)
{
    QVariantMap cfg=Json::decode(json).toMap();
    Json::saveFile(cfg,"/link/config/misc/simpleControl.json");
    if(cfg.isEmpty())
        return false;
    config=cfg;
    cmdList=cfg["cmd"].toList();

    if(!cfg["enable"].toBool())
    {
        if(uart.isOpen())
            uart.close();

        if(tcpSocket!=NULL)
        {
            disconnect(tcpSocket,SIGNAL(readyRead()),this,SLOT(onTcpRead()));
            tcpSocket->abort();
            tcpSocket->deleteLater();
            tcpSocket=NULL;
            tcp.close();
        }

        if(udp.isOpen())
        {
            udp.close();
        }
        return true;
    }


    endCode=cfg["endCode"].toString();
    argSplit=cfg["argSplit"].toString();

    QVariantMap uartCfg=cfg["uart"].toMap();
    if(uartCfg["device"].toString()!=uart.portName() || uartCfg["baudRate"].toInt()!=uart.baudRate() || !uart.isOpen())
    {
        if(uart.isOpen())
            uart.close();
        if(!uartCfg["device"].toString().isEmpty())
        {
            uart.setPortName(uartCfg["device"].toString());
            if(uart.open(QIODevice::ReadWrite))
            {
                uart.setBaudRate(uartCfg["baudRate"].toInt());
                uart.setDataBits(QSerialPort::Data8);
                uart.setParity(QSerialPort::NoParity);
                uart.setFlowControl(QSerialPort::NoFlowControl);
                uart.setStopBits(QSerialPort::OneStop);

            }
            else
            {
                qDebug()<<"can not open uart "<<uart.portName();
            }
        }
    }

    if(cfg["udp"].toInt()!=0)
    {
        if(udp.localPort()!=cfg["udp"].toInt())
        {
            udp.close();
            if(!udp.bind(cfg["udp"].toInt()))
            {
                qDebug()<<"Ctrl UDP bind error"<<tcp.errorString();
            }
            else
            {
                qDebug()<<"SimpleControl udp bind"<<cfg["udp"].toInt();
            }
        }
    }
    else
    {
        udp.close();
        udpPort=0;
    }

    if(cfg["tcp"].toInt()!=0)
    {
        if(tcp.serverPort()!=cfg["tcp"].toInt())
        {
            tcp.close();
            if(!tcp.listen(QHostAddress::Any,cfg["tcp"].toInt()))
            {
                qDebug()<<"Ctrl TCP listen error"<<tcp.errorString();
            }
            else
            {
                qDebug()<<"SimpleControl tcp bind"<<cfg["tcp"].toInt();
            }
        }
    }
    else
    {
        tcp.close();
    }

    return true;
}

QString SimpleControl::cmdTest(QString cmd)
{
    if(cmd.endsWith(endCode))
    {
        cmd=cmd.remove(endCode);
        return onRead(cmd);
    }

    return "ERROR: miss end code";
}

QString SimpleControl::startRecord(QStringList args)
{
    if(args.isEmpty())
    {
        GRecord->start();
    }
    else
    {
        int chnId=args[0].toInt();
        QVariantMap cfg=Json::loadFile(RECPATH).toMap();
        QVariantList chns=cfg["chns"].toList();
        QVariant ch=chnId;
        if(!chns.contains(ch))
            chns.append(ch);
        cfg["chns"]=chns;
        Json::saveFile(cfg,RECPATH);
        if(!GRecord->update(Json::encode(cfg)))
            return "ERROR:update failed";
    }
    return "OK";
}

QString SimpleControl::stopRecord(QStringList args)
{
    if(args.isEmpty())
    {
        GRecord->stop();
    }
    else
    {
        int chnId=args[0].toInt();
        QVariantMap cfg=Json::loadFile(RECPATH).toMap();
        QVariantList chns=cfg["chns"].toList();
        QVariant ch=chnId;
        chns.removeAll(ch);
        cfg["chns"]=chns;
        Json::saveFile(cfg,RECPATH);
        if(!GRecord->update(Json::encode(cfg)))
            return "ERROR:update failed";
    }
    return "OK";
}

QString SimpleControl::startPush(QStringList args)
{
    QString ret="OK";
    if(args.isEmpty())
    {
        GPush->start();
    }
    else
    {
        int index=args[0].toInt();
        QVariantMap cfg=GPush->config;
        QVariantList list=cfg["url"].toList();
        if(list.count()<=index)
            return "ERROR: Out of Index";
        QVariantMap map=list[index].toMap();
        map["enable"]=true;
        list[index]=map;
        cfg["url"]=list;
        GPush->update(Json::encode(cfg));
        GPush->start();
    }

    return ret;
}

QString SimpleControl::stopPush(QStringList args)
{
    QString ret="OK";
    if(args.isEmpty())
    {
        GPush->stop();
    }
    else
    {
        int index=args[0].toInt();
        QVariantMap cfg=GPush->config;
        QVariantList list=cfg["url"].toList();
        if(list.count()<=index)
            return "ERROR: Out of Index";
        QVariantMap map=list[index].toMap();
        map["enable"]=false;
        list[index]=map;
        cfg["url"]=list;
        GPush->update(Json::encode(cfg));
    }
    return ret;
}

QString SimpleControl::setOverlayText(QStringList args)
{
    QString ret="OK";
    if(args.count()!=3)
        return "ERROR: wrong args format";
    int chnId=args[0].toInt();
    int overId=args[1].toInt();
    QString text=args[2];

    Channel *chn=Config::findChannelById(chnId);
    if(chn==NULL)
        return QString("ERROR: can not find chnId %1").arg(chnId);

    QVariantMap lays;
    QVariantList list=Config::overlayList[chnId].toList();
    QVariantMap map=list[overId].toMap();
    map["content"]=text;
    list[overId]=map;
    lays["lays"]=list;
    chn->overlay->setData(lays);

    return ret;
}



QVariantMap SimpleControl::deepSetConfig(QVariantMap map, QStringList keyList, QString value, int deep)
{
    QString key=keyList[deep];
    if(!map.contains(key))
        return QVariantMap();

    if(deep==keyList.count()-1)
    {
        if(map[key].type()==QVariant::Bool)
            map[key]=(value.toLower()=="true");
        else if(map[key].type()==QVariant::String)
            map[key]=value;
        else
            map[key]=value.toInt();
    }
    else
    {
        map[key]=deepSetConfig(map[key].toMap(),keyList,value,deep+1);
    }
    return map;
}


QString SimpleControl::setConfig(QStringList args)
{
    if(args.count()!=3)
        return "ERROR: wrong args format";

    int chnId=args[0].toInt();
    QStringList keyList=args[1].split(".");
    QString value=args[2];
    QVariantList config=Json::loadFile(CFGPATH).toList();

    int index=-1;
    for(int i=0;i<config.count();i++)
    {
        if(config[i].toMap()["id"].toInt()==chnId)
            index=i;
    }

    if(index==-1)
        return QString("ERROR: can not find chnId %1").arg(chnId);

    config[index]=deepSetConfig(config[index].toMap(),keyList,value);

    if (!GRPC->update(Json::encode(config)))
        return "ERROR:update failed";

    return "OK";
}

QString SimpleControl::getConfig(QStringList args)
{
    if(args.count()!=2)
        return "ERROR: wrong args format";

    int chnId=args[0].toInt();
    QStringList keyList=args[1].split(".");
    QVariantList config=Json::loadFile(CFGPATH).toList();

    int index=-1;
    for(int i=0;i<config.count();i++)
    {
        if(config[i].toMap()["id"].toInt()==chnId)
            index=i;
    }

    if(index==-1)
        return QString("ERROR: can not find chnId %1").arg(chnId);

    QVariantMap map=config[index].toMap();
    for(int i=0;i<keyList.count()-1;i++)
    {
        QString key=keyList[i];
        if(!map.contains(key))
            return QString("ERROR: %1 is not valid").arg(args[1]);
        map=map[key].toMap();
    }

    return map[keyList.last()].toString();
}

QString SimpleControl::setEncV(QStringList args)
{
    if(args.count()!=7)
        return "ERROR: wrong args format";
    int chnId=args[0].toInt();
    QVariantList config=Json::loadFile(CFGPATH).toList();

    int index=-1;
    for(int i=0;i<config.count();i++)
    {
        if(config[i].toMap()["id"].toInt()==chnId)
            index=i;
    }

    if(index==-1)
        return QString("ERROR: can not find chnId %1").arg(chnId);

    QVariantMap data=config[index].toMap();
    QVariantMap encv=data["encv"].toMap();
    if(!args[1].trimmed().isEmpty())
        encv["width"]=args[1].toInt();
    if(!args[2].trimmed().isEmpty())
        encv["height"]=args[2].toInt();
    if(!args[3].trimmed().isEmpty())
        encv["framerate"]=args[3].toInt();
    if(!args[4].trimmed().isEmpty())
        encv["codec"]=args[4];
    if(!args[5].trimmed().isEmpty())
        encv["bitrate"]=args[5].toInt();
    if(!args[6].trimmed().isEmpty())
        encv["rcmode"]=args[6];

    data["encv"]=encv;
    config[index]=data;

    if (!GRPC->update(Json::encode(config)))
        return "ERROR:update failed";

    return "OK";
}

QString SimpleControl::getEncV(QStringList args)
{
    if(args.count()!=1)
        return "ERROR: wrong args format";
    int chnId=args[0].toInt();

    Channel *chn=Config::findChannelById(chnId);
    if(chn==NULL)
        return QString("ERROR: can not find chnId %1").arg(chnId);

    QVariantMap encv=chn->data["encv"].toMap();

    QStringList list;
    list<<encv["width"].toString();
    list<<encv["height"].toString();
    list<<encv["framerate"].toString();
    list<<encv["codec"].toString();
    list<<encv["bitrate"].toString();
    list<<encv["rcmode"].toString();

    return list.join(argSplit.toLatin1());
}

QString SimpleControl::setEncA(QStringList args)
{
    if(args.count()!=5)
        return "ERROR: wrong args format";
    int chnId=args[0].toInt();
    QVariantList config=Json::loadFile(CFGPATH).toList();

    int index=-1;
    for(int i=0;i<config.count();i++)
    {
        if(config[i].toMap()["id"].toInt()==chnId)
            index=i;
    }

    if(index==-1)
        return QString("ERROR: can not find chnId %1").arg(chnId);

    QVariantMap data=config[index].toMap();
    QVariantMap enca=data["enca"].toMap();
    if(!args[1].trimmed().isEmpty())
        enca["codec"]=args[1];
    if(!args[2].trimmed().isEmpty())
        enca["bitrate"]=args[2].toInt();
    if(!args[3].trimmed().isEmpty())
        enca["samplerate"]=args[3].toInt();
    if(!args[4].trimmed().isEmpty())
        enca["channel"]=args[4].toInt();

    data["enca"]=enca;
    config[index]=data;

    if (!GRPC->update(Json::encode(config)))
        return "ERROR:update failed";

    return "OK";
}

QString SimpleControl::getEncA(QStringList args)
{
    if(args.count()!=1)
        return "ERROR: wrong args format";
    int chnId=args[0].toInt();

    Channel *chn=Config::findChannelById(chnId);
    if(chn==NULL)
        return QString("ERROR: can not find chnId %1").arg(chnId);

    QVariantMap enca=chn->data["enca"].toMap();

    QStringList list;
    list<<enca["codec"].toString();
    list<<enca["bitrate"].toString();
    list<<enca["samplerate"].toString();
    list<<enca["channel"].toString();

    return list.join(argSplit.toLatin1());
}

QString SimpleControl::setChnEnbale(QStringList args)
{
    if(args.count()!=2)
        return "ERROR: wrong args format";
    int chnId=args[0].toInt();
    QVariantList config=Json::loadFile(CFGPATH).toList();

    int index=-1;
    for(int i=0;i<config.count();i++)
    {
        if(config[i].toMap()["id"].toInt()==chnId)
            index=i;
    }

    if(index==-1)
        return QString("ERROR: can not find chnId %1").arg(chnId);

    QVariantMap data=config[index].toMap();
    data["enable"]=(args[1].toInt()==1);

    config[index]=data;

    if (!GRPC->update(Json::encode(config)))
        return "ERROR:update failed";

    return "OK";
}

QString SimpleControl::getChnEnbale(QStringList args)
{
    Q_UNUSED(args);
    QStringList list;
    for(int i=0;i<Config::chns.count();i++)
    {
        if(!Config::chns[i]->enable)
            continue;
        list<<QString::number(Config::chns[i]->id);
    }

    return list.join(argSplit.toLatin1());
}

QString SimpleControl::setStream(QStringList args)
{
    if(args.count()<1)
        return "ERROR: wrong args format";

    int chnId=args[0].toInt();
    QVariantList config=Json::loadFile(CFGPATH).toList();

    int index=-1;
    for(int i=0;i<config.count();i++)
    {
        if(config[i].toMap()["id"].toInt()==chnId)
            index=i;
    }

    if(index==-1)
        return QString("ERROR: can not find chnId %1").arg(chnId);

    args.removeFirst();
    for(int i=0;i<args.count();i++)
        args[i]=args[i].trimmed().toLower();
    QVariantMap data=config[index].toMap();
    QVariantMap stream=data["stream"].toMap();

    QStringList list1,list2;
    list1<<"rtmp"<<"rtsp"<<"http"<<"hls"<<"webrtc";
    list2<<"rtsp"<<"push"<<"udp"<<"srt"<<"rist";

    foreach (QString key, list1) {
        if(args.contains(key))
            stream[key]=true;
        else
            stream[key]=false;
    }

    foreach (QString key, list2) {
        QVariantMap map=stream[key].toMap();
        if(args.contains(key))
            map["enable"]=true;
        else
            map["enable"]=false;
        stream[key]=map;
    }

    QVariantMap ndi=data["ndi"].toMap();
    if(args.contains("ndi"))
        ndi["enable"]=true;
    else
        ndi["enable"]=false;

    data["ndi"]=ndi;
    data["stream"]=stream;

    config[index]=data;

    if (!GRPC->update(Json::encode(config)))
        return "ERROR:update failed";

    return "OK";
}

QString SimpleControl::getStream(QStringList args)
{
    if(args.count()!=1)
        return "ERROR: wrong args format";

    int chnId=args[0].toInt();

    Channel *chn=Config::findChannelById(chnId);
    if(chn==NULL)
        return QString("ERROR: can not find chnId %1").arg(chnId);

    QVariantMap data=chn->data;
    QVariantMap stream=data["stream"].toMap();

    QStringList list1,list2,ret;
    list1<<"rtmp"<<"rtsp"<<"http"<<"hls"<<"webrtc";
    list2<<"rtsp"<<"push"<<"udp"<<"srt"<<"rist";

    foreach (QString key, list1) {
        if(stream[key].toBool())
            ret<<key;
    }

    foreach (QString key, list2) {
        if(stream[key].toMap()["enable"].toBool())
            ret<<key;
    }

    if(data["ndi"].toMap()["enable"].toBool())
        ret<<"ndi";

    qDebug()<<stream["rtmp"];

    return ret.join(argSplit.toLatin1());
}

QString SimpleControl::setLayId(QStringList args)
{
    if(args.count()!=1)
        return "ERROR: wrong args format";
    int layId=args[0].toInt();

    QVariantList layouts;
    QVariantList list=Json::loadFile(DEFLAYS_CONF).toList();
    for(int i=0;i<list.count();i++)
    {
        if(list[i].toMap()["layId"].toInt()==layId)
        {
            layouts=list[i].toMap()["layouts"].toList();
        }
    }

    if(layouts.count()==0)
        return QString("ERROR: can not find layId %1").arg(layId);

    QVariantList lays;
    for(int i=0;i<layouts.count();i++)
    {
        lays<<layouts[i].toMap()["pos"].toMap();
    }

    QVariantList config=Json::loadFile(CFGPATH).toList();
    QVariantMap data=config.last().toMap();
    data["layout"]=lays;
    config[config.count()-1]=data;

    if (!GRPC->update(Json::encode(config)))
        return "ERROR:update failed";

    return "OK";
}

QString SimpleControl::setLaySrcV(QStringList args)
{
    if(args.count()<1)
        return "ERROR: wrong args format";
    QVariantList config=Json::loadFile(CFGPATH).toList();
    QVariantMap data=config.last().toMap();
    QVariantList srcv;
    for(int i=0;i<args.count();i++)
    {
        if(args[i].isEmpty())
            srcv<<-1;
        else
            srcv<<args[i].toInt();
    }

    data["srcV"]=srcv;
    config[config.count()-1]=data;

    if (!GRPC->update(Json::encode(config)))
        return "ERROR:update failed";

    return "OK";
}

QString SimpleControl::setLaySrcA(QStringList args)
{
    if(args.count()<1)
        return "ERROR: wrong args format";
    QVariantList config=Json::loadFile(CFGPATH).toList();
    QVariantMap data=config.last().toMap();
    QVariantList srca;
    srca<<"line";
    for(int i=0;i<args.count();i++)
    {
        if(args[i].isEmpty())
            srca<<-1;
        else
            srca<<args[i].toInt();
    }

    data["srcA"]=srca;
    config[config.count()-1]=data;

    if (!GRPC->update(Json::encode(config)))
        return "ERROR:update failed";

    return "OK";
}