#include "ChannelNet.h"
#include <QFile>
#include <unistd.h>
#include "Json.h"
#include "Config.h"

ChannelNet::ChannelNet(QObject *parent) :
 Channel(parent)
{
 dv=Link::create("DecodeV");
 net=Link::create("InputNet");
#if !defined HI3516E && !defined HI3516CV610
 ndi=Link::create("NDIRecv");
#else
 ndi=NULL;
#endif
 audio=Link::create("Resample");
 decA=Link::create("DecodeA");
 ev=Link::create("EncodeV");
 encV2=Link::create("EncodeV");
 ea=Link::create("EncodeA");
 queue=Link::create("Queue");
 video=Link::create("Crop");
 encV=queue;
 encA=queue;

 haveAudio=false;
 haveVideo=false;
 haveVideo2=false;
 containsB = false;
 streamInfo = QVariantMap({{"infoA", QVariantMap()},{"infoV", QVariantMap()}});
}

void ChannelNet::init(QVariantMap)
{
 dv->linkV(video);
 video->linkV(ev);
 video->linkV(encV2);
 gain->linkA(ea);

 queue->linkV(dv);
 queue->linkA(decA);
 net->linkV(dv);
 net->linkA(decA)->linkA(audio);
 dv->linkE(decA);

 bool plate = false;
 if(QFile::exists(HARDWAREPATH))
 {
 QVariantMap hardware = Json::loadFile(HARDWAREPATH).toMap();
 plate = hardware["function"].toMap()["netPic"].toBool();
 }
 if(plate)
 {
 QVariantMap dd;
 dd["pic"] = "/link/config/nosignal.yuv";
 dv->setData(dd);
 }

 connect(net,SIGNAL(newEvent(QString,QVariant)),this,SLOT(onNewEvent(QString,QVariant)));
 if(ndi != NULL)
 connect(ndi,SIGNAL(newEvent(QString,QVariant)),this,SLOT(onNewEvent(QString,QVariant)));
 connect(dv,SIGNAL(newEvent(QString,QVariant)),this,SLOT(onNewEventDec(QString,QVariant)));

 Channel::init();
}

void ChannelNet::updateConfig(QVariantMap cfg)
{
 if(cfg["enable"].toBool() )
 {
 QVariantMap nd;
 QString path = cfg["net"].toMap()["path"].toString();
 nd["path"]=path;
 nd["protocol"]=cfg["net"].toMap()["protocol"].toString();
 nd["minDelay"]=cfg["net"].toMap()["minDelay"].toInt();
 nd["timeout"]=20;

 int bm=cfg["net"].toMap()["bufferMode"].toInt();

 if(bm==0)
 {
 nd["lowLatency"]=false;
 nd["buffer"]=true;
 nd["sync"]=false;
 nd["timestampMode"]="auto";
 }
 else if(bm==1)
 {
 nd["lowLatency"]=true;
 nd["buffer"]=false;
 nd["sync"]=false;
 nd["timestampMode"]="auto";
 }
 else if(bm==2)
 {
 nd["lowLatency"]=true;
 nd["buffer"]=false;
 nd["sync"]=false;
 nd["timestampMode"]="auto";
 }
 else if(bm==3)
 {
 nd["lowLatency"]=true;
 nd["buffer"]=false;
 nd["sync"]=false;
 nd["timestampMode"]="sync";
 }

 if(containsB || bm==2 || bm==3)
 {
 QVariantMap dd;
 dd["delay"]=cfg["net"].toMap()["minDelay"].toInt();
 queue->start(dd);
 }
 else
 queue->stop();

 if(ndi != NULL && (path.toLower().startsWith("ndi://")))
 {
 net->unLinkV(queue);
 net->unLinkA(queue);
 net->unLinkV(dv);
 net->unLinkA(decA);
 net->stop();

 if(bm == 2 || bm ==3)
 {
 ndi->unLinkV(dv);
 ndi->unLinkA(decA);
 ndi->linkV(queue);
 ndi->linkA(queue);
 }
 else
 {
 ndi->unLinkV(queue);
 ndi->unLinkA(queue);
 ndi->linkV(dv);
 ndi->linkA(decA);
 }
 QVariantMap ndd;
 ndd["name"] = path.replace("ndi://","");
 ndd["name"] = path.replace("NDI://","");
 ndi->start(ndd);
 }
 else
 {
 if(ndi != NULL)
 {
 ndi->unLinkV(queue);
 ndi->unLinkA(queue);
 ndi->unLinkV(dv);
 ndi->unLinkA(decA);
 ndi->stop();
 }
 if(containsB || bm == 2 || bm ==3)
 {
 net->unLinkV(dv);
 net->unLinkA(decA);
 net->linkV(queue);
 net->linkA(queue);
 }
 else
 {
 net->unLinkV(queue);
 net->unLinkA(queue);
 net->linkV(dv);
 net->linkA(decA);
 }
 net->start(nd);
 }


 LinkObject *nextEncV=encV;
 if(cfg["net"].toMap()["decodeV"].toBool())
 {
 QVariantMap cropMap;
 if(cfg.contains("cap"))
 {
 cropMap = cfg["cap"].toMap()["crop"].toMap();
 cropMap["pass"] = true;
 }
 video->start(cropMap);

 if(cfg["encv"].toMap()["codec"].toString()!="close")
 {
 nextEncV=ev;
 QVariantMap frm;
 frm["srcFramerate"]=cfg["net"].toMap()["framerate"].toInt();
 ev->setData(frm);
 encV2->setData(frm);

 QVariantMap encvMap = cfg["encv"].toMap();
 ev->start(encvMap);
 }
 else
 {
 nextEncV=net;
 if(containsB || bm==2 || bm==3)
 nextEncV=queue;
 ev->stop();
 }

 if(cfg["enable2"].toBool() && cfg["encv2"].toMap()["codec"].toString()!="close")
 {
 QVariantMap encv2Map = cfg["encv2"].toMap();
 encV2->start(encv2Map);
 }
 else
 {
 encV2->stop();
 }
 QVariantMap decData;
 if(cfg.contains("cap"))
 decData["rotate"] = cfg["cap"].toMap()["rotate"].toInt();

 dv->start(decData);
 }
 else
 {
 dv->stop();
 ev->stop();
 video->stop();
 nextEncV=net;
 if(containsB || bm==2 || bm==3)
 nextEncV=queue;
 }

 if(nextEncV!=encV)
 {
 foreach(QString key,streamMap.keys())
 {
 encV->unLinkV(streamMap[key]->mux);
 streamMap[key]->mux->stop(key!="srt");
 nextEncV->linkV(streamMap[key]->mux);
 }
 encV=nextEncV;
 }


 LinkObject *nextEncA=encA;
 if(cfg["net"].toMap()["decodeA"].toBool())
 {
 decA->start();
 audio->start();
 nextEncA=ea;

 if(cfg["enca"].toMap()["codec"].toString()=="close")
 ea->stop();
 else
 ea->start(cfg["enca"].toMap());
 }
 else
 {
 decA->stop();
 audio->stop();
 nextEncA=net;

 if(containsB || bm==2 || bm==3)
 nextEncA=queue;
 }

 if(nextEncA!=encA)
 {
 foreach(QString key,streamMap.keys())
 {
 encA->unLinkA(streamMap[key]->mux);
 streamMap[key]->mux->stop(key!="srt");
 nextEncA->linkA(streamMap[key]->mux);

 if(streamMap_sub.contains(key))
 {
 encA->unLinkA(streamMap_sub[key]->mux);
 streamMap_sub[key]->mux->stop(key!="srt");
 nextEncA->linkA(streamMap_sub[key]->mux);
 }
 }
 encA=nextEncA;
 }

 }
 else
 {
 ev->stop();
 dv->stop();
 net->stop();
 if(ndi != NULL)
 ndi->stop();
 encV2->stop();
 decA->stop();
 ea->stop();
 queue->stop();
 audio->stop();
 }
 containsB = false;
 updateCodec(cfg);
 Channel::updateConfig(cfg);
}

void ChannelNet::updateCodec(QVariantMap cfg)
{
 haveVideo=streamInfo["infoV"].toMap().contains("codec");
 haveVideo2=haveVideo;

 if(haveVideo && cfg["net"].toMap()["decodeV"].toBool() && cfg["encv"].toMap()["codec"].toString()=="close")
 haveVideo=false;
 if(haveVideo && cfg["net"].toMap()["decodeV"].toBool() && cfg["encv2"].toMap()["codec"].toString()=="close")
 haveVideo2=false;

 if(!cfg["net"].toMap()["decodeA"].toBool())
 haveAudio=streamInfo["infoA"].toMap().contains("codec");
 else
 haveAudio=cfg["enca"].toMap()["codec"].toString()!="close";
}

void ChannelNet::onNewEvent(QString type, QVariant info)
{
 if(type=="ready")
 {
 streamInfo=info.toMap();
 updateCodec(data);
 Channel::updateConfig(data);
 }
}

void ChannelNet::onNewEventDec(QString type, QVariant info)
{
 if(type == "containsB")
 {
 bool hadB = info.toBool();
 if(hadB)
 {
 containsB = hadB;
 updateConfig(data);
 }
 }
}