#include "numberprocessorproxy.h"
#include "importproxy.h"
NumberProcessorProxy::NumberProcessorProxy(NumberListModel *oldModel)
{
    this->stop =false;
    this->oldModel = oldModel;
}
NumberProcessorProxy::~NumberProcessorProxy()
{
    qDebug()<<QDateTime::currentDateTime().toString("yyyy-MM-dd HH:mm:ss")\
            <<"NumberProcessorProxy Destroyed.";
}
void NumberProcessorProxy::setProcessType(NumberProcessType processType)
{
    this->processType = processType;
    int size =this->oldModel->getSegments().size();
    if(size>=100000)
        this->step1Progress = 50;
    else
        this->step1Progress = 50*((double)size/100000);
    this->step2Progress = 100-this->step1Progress;
}

void NumberProcessorProxy::setBlackList(NumberListModel *blackListModel)
{
    this->blackListModel = blackListModel;
}
void NumberProcessorProxy::abort()
{
    this->stop = true;
}
void NumberProcessorProxy::onOptimizeProgressCurrentUpdated(int current)
{
    double s1 = current;
    double s2 = this->optimizeMaxProgress;
    emit progressUpdated(step1Progress*s1/s2);
}
void NumberProcessorProxy::onOptimizeProgressMaxUpdated(int max)
{
    this->optimizeMaxProgress = max;
}
void NumberProcessorProxy::run()
{
    emit progressMaxUpdated(100);
    segments = oldModel->getSegments();
    numbers = oldModel->getNumbers();

    newModel = new NumberListModel();
    newModel->setNumberList(segments,numbers);
    QTime t;
    t.start();
    QObject::connect(newModel,SIGNAL(optimizeProgressMaxUpdated(int)),this,SLOT(onOptimizeProgressMaxUpdated(int)));
    QObject::connect(newModel,SIGNAL(optimizeProgressCurrentUpdated(int)),this,SLOT(onOptimizeProgressCurrentUpdated(int)));
    newModel->mergeSegment();
    QObject::disconnect(newModel,SIGNAL(optimizeProgressMaxUpdated(int)),this,SLOT(onOptimizeProgressMaxUpdated(int)));
    QObject::disconnect(newModel,SIGNAL(optimizeProgressCurrentUpdated(int)),this,SLOT(onOptimizeProgressCurrentUpdated(int)));
    qDebug()<<"Segment Merge Time :"<<t.elapsed();
    t.start();
    if(processType == NumberSort)
    {
        sort();
    }
    else if(processType == NumberRemoveDuplicate)
    {
        removeDuplicate();
    }
    else if(processType == NumberRemoveNotPhone)
    {
        removeNotPhone();
    }
    else if(processType == NumberRemoveBlackList)
    {
        removeBlackList();
    }
    qDebug()<<"Number Process time is :"<<t.elapsed();
    emit progressMaxUpdated(1);
    emit progressUpdated(1);
    emit numberProcessed(newModel);
}
void NumberProcessorProxy::sort()
{
    segments = newModel->getSegments();
    numbers = newModel->getNumbers();

    for(int i=0;i<segments.size();i++)
    {
        numbers[i].sort();
        double s1 = i+1;
        double s2 = segments.size();
        emit progressUpdated(step1Progress+step2Progress*s1/s2);
    }
    newModel->setNumberList(segments,numbers);
    newModel->quickSortSegment();
}
void NumberProcessorProxy::removeDuplicate()
{
    segments = newModel->getSegments();
    numbers = newModel->getNumbers();
    for(int i=0;i<segments.size();i++)
    {
        numbers[i].sort();
        for(int j=0;j<numbers.at(i).size();j++)
        {
            int k = j+1;
            if(k>numbers.at(i).size()-1)
                break;
            if(numbers.at(i).at(j)==numbers.at(i).at(k))
            {
                numbers[i].removeAt(k);
                j--;
            }
        }
        double s1 = i+1;
        double s2 = segments.size();
        emit progressUpdated(step1Progress+step2Progress*s1/s2);
    }
    newModel->setNumberList(segments,numbers);
}
void NumberProcessorProxy::removeNotPhone()
{
    segments = newModel->getSegments();
    numbers = newModel->getNumbers();
    for(int i=0;i<segments.size();i++)
    {
        if(!NumberReg::getSegmentReg().exactMatch(segments.at(i)))
        {
            segments.removeAt(i);
            numbers.removeAt(i);
            i--;
        }
        else
        {
            for(int j=0;j<numbers.at(i).size();j++)
            {
                if (!NumberReg::getLastFour().exactMatch(numbers.at(i).at(j)))
                {
                    numbers[i].removeAt(j);
                    j--;
                }
            }
            if(numbers.at(i).size()==0)
            {
                segments.removeAt(i);
                numbers.removeAt(i);
                i--;
            }
        }
        double s1 = i+1;
        double s2 = segments.size();
        emit progressUpdated(step1Progress+step2Progress*s1/s2);
    }
    newModel->setNumberList(segments,numbers);
}

void NumberProcessorProxy::removeBlackList()
{
    blackListModel->mergeSegment();
    blackListModel->quickSortSegment();
    QStringList blackListSegments = blackListModel->getSegments();
    QList<QStringList> blackListNumbers = blackListModel->getNumbers();
    //ºÚÃûµ¥ºÅÂëÈ¥ÖØ
    for(int i=0;i<blackListSegments.size();i++)
    {
        blackListNumbers[i].sort();
        for(int j=0;j<blackListNumbers.at(i).size();j++)
        {
            int k = j+1;
            if(k>blackListNumbers.at(i).size()-1)
                break;
            if(blackListNumbers.at(i).at(j)==blackListNumbers.at(i).at(k))
            {
                blackListNumbers[i].removeAt(k);
                j--;
            }
        }
    }
    segments = newModel->getSegments();
    numbers = newModel->getNumbers();
    int start = 0;
    for(int i=0;i<blackListSegments.size();i++)
    {
        for(int j=start;j<segments.size();j++)
        {
            QString blackListSegment = blackListSegments.at(i);
            QString segment = segments.at(j);
            if(segment == blackListSegment)
            {
                QStringList tmp = filterNumbers(numbers.at(j),blackListNumbers.at(i));
                if(tmp.size()!=0)
                {
                    numbers[j] = tmp;
                }
                else
                {
                    numbers.removeAt(j);
                    segments.removeAt(j);
                    j--;
                }
                start = j+1;
                break;
            }
            else if(blackListSegment < segment)
            {
                start = j;
                break;
            }
            else
            {
                start = j+1;
                continue;
            }
        }
        double s1 = i+1;
        double s2 = blackListSegments.size();
        emit progressUpdated(step1Progress+step2Progress*s1/s2);
        if(start>=segments.size())
            break;
    }
    delete blackListModel;
    newModel->setNumberList(segments,numbers);
}

QStringList NumberProcessorProxy::filterNumbers(QStringList source,QStringList filter)
{
    source.sort();
    filter.sort();
    int start = 0;
    for(int i=0;i<filter.size();i++)
    {
        for(int j=start;j<source.size();j++)
        {
            QString blackNumber = filter.at(i);
            QString number = source.at(j);
            if(blackNumber == number)
            {
                source.removeAt(j);
                j--;
                start = j;
                continue;
            }
            else if(blackNumber < number)
            {
                start = j;
                break;
            }
            else
            {
                start = j+1;
                continue;
            }
        }
        if(start>=source.size())
            break;
    }
    return source;
}