#include "Group.h"
#include "Json.h"
#include "Config.h"
#include <QFile>
#include <QDomDocument>
#include <QDateTime>

Group::Group(QObject *parent) :
 QObject(parent),timer(this)
{
 rpc=new GroupRPC();
 connect(&timer,SIGNAL(timeout()),this,SLOT(onTimer()));
}

void Group::init()
{
 if(!rpc->init())
 qDebug()<<"Init group rpc error";
 rpc->addMethod("hello",this,"hello");
 rpc->addMethod("getNetwork",this,"getNetwork");
 rpc->addMethod("setNetwork",this,"setNetwork");
 rpc->addMethod("setEncode",this,"setEncode");
 rpc->addMethod("setStream",this,"setStream");
 rpc->addMethod("reboot",this,"reboot");
 rpc->addMethod("getEPG",this,"getEPG");
 rpc->addMethod("syncEPG",this,"syncEPG");

 loadConfig();
 if(rpc->getGroupId()>=0)
 {
 timer.start(5000);
 clearMember();
 onTimer();
 }
}

void Group::loadConfig()
{
 QVariantMap cfg=Json::loadFile(GRPPATH).toMap();
 QVariantMap hdCfg=Json::loadFile(HARDWAREPATH).toMap();
 rpc->setGroupId(cfg["groupId"].toInt());
 type=hdCfg["model"].toString();
 version=Json::loadFile("/link/config/version.json").toMap();
}

void Group::onTimer()
{
 QVariantList nameList;
 for(int i=0;i<Config::chns.count();i++)
 {
 if(Config::chns[i]->enable)
 nameList<<Config::chns[i]->name;
 }
 qint64 cur=QDateTime::currentMSecsSinceEpoch();
 memberInfo[rpc->getLoaclMac()]["info"]=nameList;
 memberInfo[rpc->getLoaclMac()]["type"]=type;
 memberInfo[rpc->getLoaclMac()]["version"]=version;
 memberInfo[rpc->getLoaclMac()]["activeTime"]=cur;
 QVariantMap data;
 data["info"]=nameList;
 data["type"]=type;
 data["version"]=version;
 rpc->call("hello","any",data,true);

 foreach(QString key,memberInfo.keys())
 {
 if(memberInfo[key]["activeTime"].toLongLong()-cur>20000)
 memberInfo.remove(key);
 }
}

void Group::hello(QVariant data)
{
 QString mac=rpc->getFromMac();
 memberInfo[mac]["ip"]=rpc->getFromIp().toString().replace("::ffff:","");
 memberInfo[mac]["info"]=data.toMap()["info"];
 memberInfo[mac]["type"]=data.toMap()["type"];
 memberInfo[mac]["version"]=data.toMap()["version"];
 memberInfo[mac]["activeTime"]=QDateTime::currentMSecsSinceEpoch();

}

bool Group::clearMember()
{
 memberInfo.clear();
 // memberInfo[rpc->getLoaclMac()]["ip"]=rpc->getLocalIp().toString();
 return true;
}

bool Group::update(QVariantMap json)
{
 Json::saveFile(json,GRPPATH);
 loadConfig();
 return true;
}

QVariant Group::setNetwork(QVariant cfg)
{
 //Json::saveFile(cfg,NETPATH);
 //system("/link/shell/setNetwork.sh");
 rpc->updateNet();
 // memberInfo[rpc->getLoaclMac()]["ip"]=rpc->getLocalIp().toString();
 return true;
}

QVariant Group::setEncode(QVariant cfg)
{
 QVariantList chnList=Json::loadFile(CFGPATH).toList();
 for(int i=0;i<chnList.count();i++)
 {
 QVariantMap map=chnList[i].toMap();
 map["enca"]=cfg.toMap()["enca"].toMap();
 map["encv"]=cfg.toMap()["encv"].toMap();
 map["encv2"]=cfg.toMap()["encv2"].toMap();
 chnList[i]=map;
 }
 Json::saveFile(chnList,CFGPATH);
 Config::loadConfig(CFGPATH);
 return true;
}

QVariant Group::setStream(QVariant cfg)
{
 QVariantMap config=cfg.toMap()["cfg"].toMap();
 QVariantMap push=config["push"].toMap();
 QVariantMap udp=config["udp"].toMap();
 bool ipPlus = false;
 bool portPlus = false;
 QString ipBase1 = "";
 int ipBase2 = 0;
 int portBase = 0;
 QString udpip=config["udp"].toMap()["ip"].toString();
 QString udpport=config["udp"].toMap()["port"].toString();

 if ( udpip.endsWith( "+" ) ) {
 udpip = udpip.replace( "+", "" );
 ipPlus = true;
 int n = udpip.lastIndexOf( "." );
 ipBase1 = udpip.left(n);
 ipBase2 = udpip.mid(n+1).toInt();
 }
 if ( udpport.endsWith("+") ) {
 udpport = udpport.left(udpport.length()-1);
 portPlus = true;
 portBase = udpport.toInt();
 }

 QVariantList chnList=Json::loadFile(CFGPATH).toList();
 for(int i=0;i<chnList.count();i++)
 {
 QVariantMap map=chnList[i].toMap();
 push["path"]=map["stream"].toMap()["push"].toMap()["path"];
 config["push"]=push;

 if(ipPlus)
 udp["ip"]=ipBase1+QString::number(ipBase2+2);
 if(portPlus)
 udp["port"]=portBase+i;

 config["udp"]=udp;
 map["stream"]=config;
 chnList[i]=map;

 }
 Json::saveFile(chnList,CFGPATH);
 Config::loadConfig(CFGPATH);
 setStream2(cfg);
 return true;
}

QVariant Group::setStream2(QVariant cfg)
{
 QVariantMap config=cfg.toMap()["cfg2"].toMap();
 QVariantMap push=config["push"].toMap();
 QVariantMap udp=config["udp"].toMap();
 bool ipPlus = false;
 bool portPlus = false;
 QString ipBase1 = "";
 int ipBase2 = 0;
 int portBase = 0;
 QString udpip=config["udp"].toMap()["ip"].toString();
 QString udpport=config["udp"].toMap()["port"].toString();

 if ( udpip.endsWith( "+" ) ) {
 udpip = udpip.replace( "+", "" );
 ipPlus = true;
 int n = udpip.lastIndexOf( "." );
 ipBase1 = udpip.left(n);
 ipBase2 = udpip.mid(n+1).toInt();
 }
 if ( udpport.endsWith("+") ) {
 udpport = udpport.left(udpport.length()-1);
 portPlus = true;
 portBase = udpport.toInt();
 }

 QVariantList chnList=Json::loadFile(CFGPATH).toList();
 for(int i=0;i<chnList.count();i++)
 {
 QVariantMap map=chnList[i].toMap();
 push["path"]=map["stream2"].toMap()["push"].toMap()["path"];
 config["push"]=push;

 if(ipPlus)
 udp["ip"]=ipBase1+QString::number(ipBase2+2);
 if(portPlus)
 udp["port"]=portBase+i;

 config["udp"]=udp;
 map["stream2"]=config;
 chnList[i]=map;

 }
 Json::saveFile(chnList,CFGPATH);
 Config::loadConfig(CFGPATH);
 return true;
}

QVariant Group::getNetwork()
{
 return Json::loadFile(NETPATH);
}

QVariantList Group::getList()
{
 QVariantList list;
 QVariantMap info;
 foreach(QString mac,memberInfo.keys())
 {
 info=memberInfo[mac];
 info["mac"]=mac;
 list<<info;
 }
 return list;
}

QVariantList Group::callGetEPG()
{
 QVariantMap epgMap;
 QVariantList epgList;
 foreach(QString mac,memberInfo.keys())
 {
 QVariantMap map=rpc->call("getEPG",mac).toMap();
 foreach(QString id,map.keys())
 {
 QVariantMap chn=map[id].toMap();
 chn["id"]=id;
 epgMap[id]=chn;
 }
 }
 this->epgMap=epgMap;

 QVariantList order=Json::loadFile(GRPPATH).toMap()["order"].toList();
 for(int i=0;i<order.count();i++)
 {
 QString id=order[i].toString();
 if(!epgMap.contains(id))
 continue;
 epgList.append(epgMap.take(id));
 }

 foreach(QString id,epgMap.keys())
 {
 epgList.append(epgMap[id]);
 }

 return epgList;
}

QVariantList Group::orderEPG(QVariantList order)
{
 QVariantMap epgMap=this->epgMap;
 QVariantMap cfg=Json::loadFile(GRPPATH).toMap();
 cfg["order"]=order;
 Json::saveFile(cfg,GRPPATH);

 QVariantList epgList;

 for(int i=0;i<order.count();i++)
 {
 QString id=order[i].toString();
 if(!epgMap.contains(id))
 continue;
 epgList.append(epgMap.take(id));
 }

 foreach(QString id,epgMap.keys())
 {
 epgList.append(epgMap[id]);
 }

 return epgList;

}

QVariant Group::getEPG()
{
 QVariantList chnList=Json::loadFile(CFGPATH).toList();
 QVariantMap epgMap;
 QVariantMap map;
 for(int i=0;i<chnList.count();i++)
 {
 if(!chnList[i].toMap()["enable"].toBool())
 continue;
 if(chnList[i].toMap()["type"].toString()=="usb")
 continue;


 map["name"]=chnList[i].toMap()["name"];
 QVariantMap stream=chnList[i].toMap()["stream"].toMap();
 QStringList urls;
 urls.clear();
 QString id=QString::number(chnList[i].toMap()["id"].toInt());
 QString ip=rpc->getLocalIp().toString();
 if(stream["http"].toBool())
 urls<<"http://"+ip+"/live/stream"+id;
 if(stream["hls"].toBool())
 urls<<"http://"+ip+"/hls/stream"+id+".m3u8";
 if(stream["rtmp"].toBool())
 urls<<"rtmp://"+ip+"/live/stream"+id;
 if(stream["rtsp"].type() == QVariant::Bool)
 {
 if(stream["rtsp"].toBool())
 urls<<"rtsp:///stream"+id;
 }
 else
 {
 QVariantMap rtsp = stream["rtsp"].toMap();
 if(rtsp["enable"].toBool())
 {
 if(rtsp["auth"].toBool())
 urls<<"rtsp://"+rtsp["name"].toString()+":"+rtsp["passwd"].toString()+"@/stream"+id;
 else
 urls<<"rtsp:///stream"+id;
 }
 }
 if(stream["udp"].toMap()["enable"].toBool())
 urls<<"udp://@"+stream["udp"].toMap()["ip"].toString()+":"+QString::number(stream["udp"].toMap()["port"].toInt());
 if(stream["push"].toMap()["enable"].toBool())
 urls<<stream["udp"].toMap()["path"].toString();
 map["url"]=urls.join("|");
 epgMap[rpc->getLoaclMac()+"-"+QString::number(i)]=map;
 }
 return epgMap;

}

QVariant Group::syncEPG(QVariant epg)
{
 Json::saveFile(epg,"/link/config/epg.json");
 createEPGXML(epg.toList());

 return true;
}

bool Group::createEPG()
{
 QVariantMap epgMap=this->epgMap;
 QVariantList order=Json::loadFile(GRPPATH).toMap()["order"].toList();
 QVariantList epgList;

 for(int i=0;i<order.count();i++)
 {
 QString id=order[i].toString();
 if(!epgMap.contains(id))
 continue;
 epgList.append(epgMap.take(id));
 }

 foreach(QString id,epgMap.keys())
 {
 epgList.append(epgMap[id]);
 }

 createEPGXML(epgList);
 Json::saveFile(epgList,"/link/config/epg.json");
 return true;
}

bool Group::createEPGXML(QVariantList epgList)
{
 Json::saveFile(epgList,"/link/config/epg.json");
 QDomDocument docXML;
 QDomElement root=docXML.createElement("root");
 for(int i=0;i<epgList.count();i++)
 {
 QDomElement channel = docXML.createElement("channel");
 QDomElement name = docXML.createElement("name");
 name.appendChild(docXML.createTextNode(epgList[i].toMap()["name"].toString()));
 channel.appendChild(name);
 QStringList urls=epgList[i].toMap()["url"].toString().split("|");
 for(int k=0;k<urls.count();k++)
 {
 QDomElement url = docXML.createElement("url");
 url.appendChild(docXML.createTextNode(urls[k]));
 channel.appendChild(url);
 }
 root.appendChild(channel);
 }
 docXML.appendChild(root);
 QFile fileXML("/link/config/epg.xml");
 fileXML.open(QFile::ReadWrite);
 fileXML.resize(0);
 QTextStream out(&fileXML);
 docXML.save(out,4,QDomNode::EncodingFromTextStream);
 fileXML.close();
 return true;
}

void Group::reboot()
{
 system("reboot");
}


bool Group::callSetNetwork(QString mac, QVariantMap json)
{
 return rpc->call("setNetwork",mac,json).toBool();
}

QVariantMap Group::callGetNetwork(QString mac)
{
 return rpc->call("getNetwork",mac).toMap();
}

bool Group::callSetEncode(QString mac, QVariantMap json)
{
 return rpc->call("setEncode",mac,json).toBool();
}

bool Group::callSetStream(QString mac, QVariantMap json)
{
 return rpc->call("setStream",mac,json).toBool();
}

bool Group::callReboot(QString mac)
{
 rpc->call("reboot",mac,QVariant(),true);
 return true;
}

bool Group::callSyncEPG(QString mac)
{
 QVariant epg=Json::loadFile("/link/config/epg.json");
 return rpc->call("syncEPG",mac,epg).toBool();
}