//
//  main.cpp
//  AutoGrader
//
//  Created by Robert LiKamWa on 9/17/13.
//  Copyright (c) 2013 Robert LiKamWa. All rights reserved.
//

#include "dirent.h"
#include <stdio.h>
#include <string>
#include <iostream>
#include <fstream>
#include <stdlib.h>
#include <opencv2/core/core.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/features2d/features2d.hpp>
#include <opencv2/imgproc/imgproc.hpp>
#include <AppKit/NSOpenPanel.h>

//#include <opencv2/video/background_segm.hpp>

using namespace cv;
using namespace std;

string corners_window="corners_window";
string execpath, templatepath, outputpath, inputpath;
Point2f rightP,leftP,topP;
int Npts;
int thresh=100;
void showim(Mat image){
    /*namedWindow( "Display window", CV_WINDOW_AUTOSIZE );// Create a window for display.
    imshow( "Display window", image );
    waitKey(0);*/
}
string intstr(int a){
    stringstream ss;//create a stringstream
    ss << a;//add number to the stream
    return ss.str();
}

void locateReds(Mat image){
    Mat channel[3];
    split(image, channel);
   
    //BGR
    Mat red = channel[2]>(channel[0]+100);
    showim(red);
    for (int i=0;i<image.rows;i++){
        for (int j=0;j<image.rows;j++){
            
        }
    }
    // find red blobs
    cv::SimpleBlobDetector::Params params;
    params.minDistBetweenBlobs = 10.0f;
    params.filterByInertia = false;
    params.filterByConvexity = false;
    params.filterByColor = false;
    params.filterByCircularity = false;
    params.filterByArea = true;
    params.minArea = 10.0f;
    params.maxArea = 1000.0f;
    cv::Ptr<cv::FeatureDetector> blob_detector = new cv::SimpleBlobDetector(params);
    blob_detector->create("SimpleBlob");
    
    vector<cv::KeyPoint> redpoints;
    blob_detector->detect(red, redpoints);
    
    Npts = int(redpoints.size());
    std::cout<<Npts<<" red points";
    float dists[Npts][Npts];
    int maxi,maxj;
    float maxd=0;

    //find hypotenuse
    for (int i=0;i<Npts;i++){
        for (int j=0;j<Npts;j++){
            cv::Point d = redpoints[i].pt-redpoints[j].pt;
            dists[i][j]=d.dot(d);
            if (maxd<dists[i][j]){
                maxd=dists[i][j];
                maxi=i;
                maxj=j;
            }
        }
    }

    //find max distance from line to find right angle point
    cv::Point P0=redpoints[maxi].pt;
    cv::Point P1=redpoints[maxj].pt;
    
    float a = P0.y - P1.y;
    float b = P1.x - P0.x;
    float c = P0.x * P1.y - P1.x * P0.y;
    
    // initialize min index and distance to P[0]
    int mi = 0;
    maxd = 0;
    for (int i=0;i<Npts;i++){
        cv::Point P=redpoints[i].pt;
        float dist = abs(a * P.x + b * P.y  + c);
        if (dist>maxd){
            maxd=dist;
            mi=i;
        }
    }
    
    rightP = redpoints[mi].pt;
    
    if (a * rightP.x + b * rightP.y  + c<0){
        leftP=P1;
        topP=P0;
    }else{
        leftP=P0;
        topP=P1;
    }
}

Point2f rightP2, leftP2, topP2;
int bubNRows,bubNCols;
float bubRad;
float bubRowsY[20];
float bubColsX[20];
int commentsRowsY[40];
int commentsXL=768;
int commentsXR=1169;

string dirChooser(NSString *title, NSString * startdir){
    NSOpenPanel *panel = [NSOpenPanel openPanel];
    [panel setCanChooseFiles:NO];
    [panel setCanChooseDirectories:YES];
    [panel setDirectoryURL:[NSURL URLWithString:startdir]];
    //[panel setAllowsMultipleSelection:YES]; // yes if more than one dir is allowed
    [panel setTitle:title];
    NSInteger clicked = [panel runModal];
    
    if (clicked != NSFileHandlingPanelOKButton) {
        //clicked = [panel runModal];
        exit(0);
    }
    NSString * str = [[panel URL] path];
    //NSLog(str);
    string s = [str UTF8String];
    cout<<s<<endl;
    
    return s;
}

void readTemplate(int N){
    topP2=Point2f(1190,102);
    rightP2=Point2f(1190,1546);
    leftP2=Point2f(121,1546);
    
    stringstream ss;//create a stringstream
    ss << N;//add number to the stream
    /*string bubblesfile= "/Users/roblkw/Sites/screech_2013/AutoGrader/Template/Bubbles/BubblesTemplate" + ss.str()+ ".png";
    bubble_image=imread(bubblesfile);*/
    
//    int i;
    float f1;
    float f2;
    //string inname = execpath+"/Template/Params/ParamsTemplate" + ss.str()+ ".png.txt";
    //string comments_name = execpath+"/Template/Params/CommentsTemplate" + ss.str()+ ".png.txt";
    
    string inname = templatepath+"/ParamsTemplate" + ss.str()+ ".png.txt";
    string comments_name = templatepath+"/CommentsTemplate" + ss.str()+ ".png.txt";
    
    ifstream paramfile(inname.c_str());
    ifstream commentsfile(comments_name.c_str());
    
    paramfile>>f1;
    paramfile>>f2;
    topP2=Point2f(f1,f2);
    paramfile>>f1;
    paramfile>>f2;
    leftP2=Point2f(f1,f2);
    paramfile>>f1;
    paramfile>>f2;
    rightP2=Point2f(f1,f2);
    
    paramfile>>bubRad;
    
    paramfile>>bubNCols;
    for (int i=0;i<bubNCols;i++){
        paramfile>>bubColsX[i];
        cout<<bubColsX[i]<<" ";
    }
    cout<<endl;
    paramfile>>bubNRows;
    commentsfile>>commentsXL;
    commentsfile>>commentsXR;
    cout<<"Comments X:"<<commentsXL<<","<<commentsXR<<endl;
    for (int i=0;i<bubNRows;i++){
        paramfile>>bubRowsY[i];
        cout<<bubRowsY[i]<<" ";
        commentsfile>>commentsRowsY[i*2];
        commentsfile>>commentsRowsY[i*2+1];
        //cout<<commentsRowsY[i*2]<<endl;
        //cout<<commentsRowsY[i*2+1]<<endl;
    }
    cout<<endl;
    cout<<"params: "<<bubRad<<","<<bubNCols<<","<<bubNRows<<endl;
    
}

Mat redPointTransform(Mat image){
    Point2f src[3]; src[0]=rightP;  src[1]=leftP;  src[2]=topP;
    Point2f dst[3]; dst[0]=rightP2; dst[1]=leftP2; dst[2]=topP2;
    
    Mat aff = getAffineTransform(src,dst);
    Mat alignedImage;
    
    warpAffine(image,  alignedImage,aff, cv::Size(1200,1550),cv::INTER_LINEAR,BORDER_TRANSPARENT);
    return alignedImage;
}
double dist2(double x,double y,double xx,double yy){
    return (x-xx)*(x-xx)+(y-yy)*(y-yy);
}

vector<int> voteCount(Mat alignedImage){
    cout<<"voteCount: "<<bubNRows<<","<<bubNCols<<endl;
    long votes[bubNRows][bubNCols];
    for (int j=0;j<bubNRows;j++){
        for (int i=0;i<bubNCols;i++){
            votes[j][i]=0;
        }
    }
    Mat channels[3];
    split(alignedImage,channels);
    cout<<alignedImage.cols<<","<<alignedImage.rows<<endl;
    //showim(channels[2]<thresh);
    Mat newImage=channels[2]/3;
    thresh=500;
    for (int i=0;i<alignedImage.cols;i++){
        for (int j=0;j<alignedImage.rows;j++){
            
            int pixelvalue = alignedImage.at<Vec3b>(j,i)[2];
                if (pixelvalue<thresh){//using red channel...
                    int voteY=-1;
                    int voteX=-1;
                    //which row? speaker
                    for (int by=0;by<bubNRows;by++){
                       if (abs(bubRowsY[by]-j)<bubRad){
                            voteY=by;
                        }
                    }
                    
                    //which column? 1-10
                    for (int bx=0;bx<bubNCols;bx++){
                        if (abs(bubColsX[bx]-i)<bubRad){
                            voteX=bx;
                        }
                    }
                    
                    if (voteY>=0 && voteX>=0){
                       //cout<<voteY<<","<<voteX<<endl;
                        if (dist2(i,j,bubColsX[voteX],bubRowsY[voteY])<bubRad*bubRad){
                            newImage.at<uchar>(j,i)=255;
                            votes[voteY][voteX]+=(255-pixelvalue);
                        }
                    }
                    //find nearest bubble center
                }
                
            }
            //cout<<"hey"<<endl;
        }
    showim(newImage);
    //aggregate votes
    
    for (int i=0;i<bubNRows;i++){
        //cout<<bubRowsY[i]<<",";
    }
    //cout<<endl;
    //cout<<"scores"<<endl;
    vector<int> scores;
    for (int j=0;j<bubNRows;j++){
        int maxVotes=0;
        int argMaxVotes=-1;
        for (int i=0;i<bubNCols;i++){
            if (votes[j][i]>maxVotes && votes[j][i]>6000){
                maxVotes=int(votes[j][i]);
                argMaxVotes=i;
            }
            //cout <<votes[j][i]<< ",";
        }
        //scores[j]=argMaxVotes+1;
        scores.push_back(argMaxVotes+1);
        //cout <<endl;
    }
    //cout<<"endscores"<<endl;
    return scores;
}

int numPages=4;
//const char* inputfile=execpath+"/Input/Input.pdf";
vector<vector<vector<int> > > rawScores;
void addScores(int pagenum, vector<int>scores){
    rawScores[pagenum-1].push_back(scores);
}
vector<double> aggrScores(){
    vector<double> scoresTally;
    for (int i=0;i<rawScores.size();i++){
        if (rawScores[i].size()>0){
        for (int k=0;k<rawScores[i][0].size();k++){
            int s_sum=0;
            int s_count=0;
            for (int j=0;j<rawScores[i].size();j++){
                if (rawScores[i][j][k]>0){
                    s_sum+=rawScores[i][j][k];
                    s_count++;
                }
            }
            if (s_count>0){
            scoresTally.push_back(double(s_sum)/s_count);
            }else{
                scoresTally.push_back(double(0));
            }
            cout<<scoresTally.back()<<endl;
        }
        }
    }
    return scoresTally;
}
vector<string>  textfile_to_vector(string filename){
    vector<string> text_file;
    
    ifstream ifs( filename.c_str() );
    string temp;
    
    while( getline( ifs, temp ) ){
        text_file.push_back( temp );
       //cout<<"read:"<<temp<<endl;
    }
    return text_file;
}

struct screecher{
    double score;
    string text;
    int flight;
    int dept;
};
bool compareByScore(const screecher &a, const screecher &b)
{
    return a.score > b.score;
}
string to_string1(int number){
    string number_string = "";
    char ones_char;
    int ones = 0;
    while(true){
        ones = number % 10;
        switch(ones){
            case 0: ones_char = '0'; break;
            case 1: ones_char = '1'; break;
            case 2: ones_char = '2'; break;
            case 3: ones_char = '3'; break;
            case 4: ones_char = '4'; break;
            case 5: ones_char = '5'; break;
            case 6: ones_char = '6'; break;
            case 7: ones_char = '7'; break;
            case 8: ones_char = '8'; break;
            case 9: ones_char = '9'; break;
    //        default : ErrorHandling("Trouble converting number to string.");
        }
        number -= ones;
        number_string = ones_char + number_string;
        if(number == 0){
            break;
        }
        number = number/10;
    }
    return number_string;
}
//int commentsRowsY[40];
//int commentsXL=337;
//int commentsXR=510;
void extractComments(Mat alignedImage, int pagenum, int pp){
    if (commentsRowsY[0]==-1){
        cout<<"No Comments"<<endl;
        return;
    }
    for (int i=0;i<bubNRows;i++){
        int height =commentsRowsY[2*i+1]-commentsRowsY[2*i];
        
        int width = min(commentsXR,alignedImage.cols-1) - commentsXL;
        string outputdir=outputpath+"/Comments/comm"+to_string1(pagenum)+"_"+to_string1(i)+"/";
        string mkdir="mkdir -p "+outputdir;
        string outputpath=outputdir+to_string1(pp)+".png";
        system(mkdir.c_str());
        cout<<commentsXL<<","<<commentsRowsY[2*i]<<","<<width<<","<<height<<endl;
        
        Mat commentsImage = alignedImage(cv::Rect(commentsXL,commentsRowsY[2*i], width,height));
        imwrite(outputpath,commentsImage);
    }
}
int NUMPAGES=4;
int main(int argc, const char * argv[])
{
    int i = system("export PATH=/opt/ImageMagick/bin:/opt/GhostScript/bin:/usr/local/bin/:/opt/local/bin:/$PATH; convert -version");
    if (i!=0){
        cout<<"Error "<<i<<": Could not find ImageMagick. Please install."<<endl;
        exit(1);
    }
    
    int pp=0;
    std::ofstream outputstr[4];
    std::ofstream outTally;
    std::ofstream outSorted;
    std::ofstream outFlightWin;
    std::ofstream outBestDept;
    execpath= argv[0];
    execpath = execpath.substr(0,execpath.find_last_of("/"));
    NSString * NSexecpath = [NSString stringWithUTF8String:execpath.c_str()];
    
    templatepath=dirChooser(@"Template Folder",NSexecpath);
    inputpath=dirChooser(@"Input Folder (with Input.pdf)",NSexecpath);
    outputpath=dirChooser(@"Output Folder",NSexecpath);
    templatepath=templatepath+"/";
    inputpath=inputpath+"/";
    outputpath=outputpath+"/";
    //string inputpath=execpath+"/Input/";
    //string outputpath=execpath+"/Output/";
    
    
    string tallypath=outputpath+"Tally.txt";
    string sortedpath=outputpath+"Sorted.txt";

    outTally.open(tallypath.c_str());
    outSorted.open(sortedpath.c_str());

    for (int i=1;i<=NUMPAGES;i++){
        string outputstrstr=outputpath+"raw_out"+intstr(i)+".csv";
        outputstr[i-1].open(outputstrstr.c_str());
        vector<vector<int> > vectorforpage;
        rawScores.push_back(vectorforpage);
    }
    
    //Use convert to generate .png files
   
    string input = "export PATH=/usr/local/bin/:/opt/local/bin:/$PATH; convert '"+inputpath+"input.pdf' '"+inputpath+"input%d.png'";
    cout<<input<<endl;
    system(input.c_str());
    DIR *dir;
    struct dirent *ent;
    if ((dir = opendir (inputpath.c_str())) != NULL) {
        /* print all the files and directories within directory */
        while ((ent = readdir (dir)) != NULL) {
            string filename = ent->d_name;
            size_t i = filename.rfind(".png");
            if ((i != string::npos) && (i == (filename.length() - 4))){
                cout<<filename<<endl;
                string fullfilepath=inputpath+filename;
                cout<<inputpath+filename<<endl;
                Mat imagein=imread(fullfilepath.c_str());
//                Mat imagein=imread(impath);
                Mat image;
                resize(imagein,image,cv::Size(1275,1650));
                if (image.rows>0){
                //Find Red Points rightP, leftP, topP
                locateReds(image);
                int pagenum = Npts-2; //std::cout<<"PageNum "<< pagenum <<endl;
                cout<<"Page: "<<pagenum<<endl;
                readTemplate(pagenum);
                
                //Transform using RedPoints
                Mat alignedImage = redPointTransform(image);
                vector<int> scores = voteCount(alignedImage);
                addScores(pagenum,scores);
                
                //Append to file
                for (int j=0;j<bubNRows;j++){
                    outputstr[pagenum-1]<<scores[j]<< ",";
                }
                outputstr[pagenum-1]<<endl;
                extractComments(alignedImage,pagenum,pp);
                pp++;
                }
            }
        }
        closedir (dir);
    } else {
        /* could not open directory */
        perror ("");
        return EXIT_FAILURE;
    }

    vector<double> scoresTally = aggrScores();
    cout<<scoresTally.size()<<endl;
    //Write to file
    for (int j=0;j<scoresTally.size();j++){
        cout<<scoresTally[j]<<endl;
        outTally<<scoresTally[j]<<endl;
    }
    
    //Winners
    string namepath = templatepath+"names.txt";
    vector<string> names = textfile_to_vector(namepath);
    vector<screecher> screechers;
    for (int j=0;j<scoresTally.size();j++){
        screecher s;
        s.score=scoresTally[j];
        s.text=names[j];
        screechers.push_back(s);
    }
    std::sort(screechers.begin(), screechers.end(), compareByScore);
    
    for (int j=0;j<screechers.size();j++){
        screecher s = screechers[j];
        outSorted<<s.score<<":"<<s.text<<endl;
        if (j<5){
            cout<<s.score<<":"<<s.text<<endl;
        }
    }
        return 0;
}