#include "loadmapping.h"

#include <iostream>
QHash<QString,QVector<QSharedPointer<LoadInfo> > >  *LoadMapping::loads=NULL;
QHash<QString,QSharedPointer<LoadInfo> > *LoadMapping::loadsToLoadInfo=NULL;
LoadMapping::LoadMapping()
{
//    if(!LoadMapping::ht)
//    {
//        LoadMapping::ht=new QHash<QString,QVector<double> >;
//    }
    if(!LoadMapping::loads)
    {
        LoadMapping::loads=new QHash<QString,QVector<QSharedPointer<LoadInfo> > >;
    }
    if(!LoadMapping::loadsToLoadInfo)
    {
        LoadMapping::loadsToLoadInfo=new QHash<QString,QSharedPointer<LoadInfo> >;
    }

}


LoadMapping::~LoadMapping()
{

}

bool LoadMapping::broadcastUpdateByTime(const QTime& time)
{
    QList<QString> keys;
    keys=LoadMapping::loadsToLoadInfo->keys();
    for(QList<QString>::iterator ite=keys.begin();
        ite!=keys.end();
        ite++
        )
    {
        QSharedPointer<LoadInfo> t=(*LoadMapping::loadsToLoadInfo)[*ite];
        t->updateByTime(time);
    }
    return true;
}

QSharedPointer<LoadInfo> LoadMapping::getALoad(const QString& id)
{
    return (*this->loadsToLoadInfo)[id];
}

QVector<QSharedPointer<LoadInfo> > LoadMapping::getSubstationLoad(const QString& id)
{
    if(!this->loads->contains(id))
    {
        return QVector<QSharedPointer<LoadInfo> >();
    }
    return (*this->loads)[id];
}

bool LoadMapping::load(const QString &loadDir,const QString &matchdDir,const QString &exceptionFile)
{

    if(LoadMapping::loadsToLoadInfo->keys().length()>0)
    {
        return true;//只执行一次
    }
    if(!QFileInfo::exists(loadDir))
    {
        std::cout<<"load file not exists."<<std::endl;
        return false;
    }
    if(!QFileInfo::exists(matchdDir))
    {
        std::cout<<"match file not exists."<<std::endl;
        return false;
    }
    if(!QFileInfo::exists(exceptionFile))
    {
        std::cout<<"match file not exists."<<std::endl;
        return false;
    }

    if(!this->readMatch(matchdDir))
    {
        std::cout<<"read match failed"<<std::endl;
        return false;
    }
    this->loadMatchException.init(exceptionFile);

    if(!this->readLoads(loadDir))
    {
        std::cout<<"read load failed"<<std::endl;
        return false;
    }

    return true;

}

bool LoadMapping::readLoads(const QString &dir)
{
    RecurseDir recurseDir;
    recurseDir.setDir((dir));
    QStringList filePathList=recurseDir.getFiles();
    foreach(QString filePath,filePathList)
    {
        QFileInfo fileInfo(filePath);
        if(!fileInfo.exists())
        {
            return false;
        }
        QString suffix;
        suffix=fileInfo.suffix();
        if(suffix.toLower()!="csv")
        {
            continue;
        }
        QString fileName=fileInfo.baseName();

        if(this->loadMatchException.contains(fileName))
        {
            std::cout<<"ignore "<<fileName.toLocal8Bit().data()<<std::endl;
            continue;
        }
        if(!this->loadsToLoadInfo->contains(fileName))
        {
            std::cout<<filePath.toLocal8Bit().data()<<" no match."<<std::endl;
            continue;
        }
        QSharedPointer<LoadInfo> loadInfo=(*this->loadsToLoadInfo)[fileName];
//        std::cout<<"file name "<<fileName.toLocal8Bit().data()<<std::endl;
        loadInfo->setLoadPath(filePath);

    }
    return true;
}


bool LoadMapping::readMatch(const QString& dir)
{
    RecurseDir recurseDir;
    recurseDir.setDir((dir));
    QStringList filePathList=recurseDir.getFiles();
    foreach(QString filePath,filePathList)
    {
        QFileInfo fileInfo(filePath);
        if(!fileInfo.exists())
        {
            return false;
        }
        QString suffix;
        suffix=fileInfo.suffix();
        if(suffix.toLower()!="csv")
        {
            continue;
        }
        QFile file(filePath);
        QString line;
        QStringList sep;
        if(file.open(QFile::ReadOnly))
        {
            QTextStream reader(&file);
            while(!reader.atEnd())
            {
                line=reader.readLine().trimmed();
                sep=line.split(',');
                if(sep.length()<2)
                {
                    continue;
                }
                QString SFDid;
                QRegExp regExp("\\(.*\\)");
                SFDid=sep.at(0);
                SFDid=SFDid.replace(regExp,"");
//                QVector<QSharedPointer<LoadInfo> > loads;
                for(int i=1;i<sep.length();i++)
                {
                    if(sep.at(i).trimmed().length()==0)
                    {
                        break;
                    }
                    QSharedPointer<LoadInfo> t(new LoadInfo);
                    t->setLoadName(sep.at(i));
//                    if(sep.at(i).trimmed()=="")
//                    {
//                        std::cout<<"empy "<<SFDid.toStdString()<<std::endl;
//                    }

//                    std::cout<<SFDid.toStdString()<<std::endl;
//                    loads.push_back(t);
                    (*this->loadsToLoadInfo)[sep.at(i)]=t;
//                    if(SFDid=="SFD-43064")
//                    {
//                        std::cout<<"SFD-43064 "<<sep.at(i).toLocal8Bit().data()<<std::endl;
//                        std::cout<<this->getSubstationLoad("SFD-43064").length()<<std::endl;
//                    }
                    (*this->loads)[SFDid].push_back(t);

                }

            }
            file.close();
        }

    }
    return true;
}