#include <cstdlib>
#include <iostream>
#include <fstream>
#include <string>
#include <list>
#include <vector>
#include <getopt.h>
#include <iomanip>
#include <algorithm>
#include <tgmath.h>
#include<map>
#include <set>

using namespace std;

string inputfname;
string outputfname;
string* indata = 0;
vector <int> dlugosci;
vector <string> naglowki;
vector <int> czy_rowne;
char **matryca;
float **wynikowa;

class sekwencja
{
public:
    int ileA;
    int ileC;
    int ileT;
    int ileG;
    string idseq;
    string seq;
    /**trzeba bedzie zrobic chyba oddzielna klase czy cos zeby stackowac wyniki tych PAR
    albo inna strukture jak slownik/hasz**/
};

vector <sekwencja> seqstack;

string* readfile(string filename)
{

string* result = new string(); /** tabela wskaznikow na stringi pochodzace z wejscia **/

	ifstream inputfile;

	inputfile.open(filename.c_str());

        dlugosci.push_back(0);
        if (inputfile.is_open() )
        {
		string s;
		string nagl;
		int ile=0; //dlugosc calej sekwencji
		int licznik=0;
		while (!inputfile.eof()) {

			getline(inputfile,nagl);
			if(nagl.find(">")==0)
            {
                if(licznik>0)
                {
                    dlugosci.push_back(ile);
                }
                naglowki.push_back(nagl);
                continue;
            }
            else
            {

                s=nagl;
                czy_rowne.push_back(s.size());
                ile=ile+s.size();

            }
			result->append(s);
			licznik++;
		}
        inputfile.close();
	}
	return result;
}

int main(int argc, char *argv[])
{
    int posi;
    int przelacznik=0;
    for (int i=0; i<argc; i++ )
    {
        string s(argv[i]);
        posi = s.find("-finput");
        if (posi >=0)
        {
           s.erase(0,7);
           inputfname.assign(s);
        }
    }
    indata = readfile(inputfname);
    string przetwarzane = *indata;
    set<int> s( czy_rowne.begin(), czy_rowne.end() ); /** usuwnie duplikatow z wektora**/
    if(s.size()>1)
    {
        cout<<"Blad! Sekwencje nie sa rowne!!"<<endl;
        return 0;
    }
    string teraz;
    int tyle=0;
    for(int x=0;x<dlugosci.size();x++)
    {
            teraz=przetwarzane.substr(dlugosci[x],czy_rowne[0]);
            sekwencja A;
            A.idseq=naglowki[x];
            A.seq=teraz;
            cout<<A.idseq<<endl;
            cout<<A.seq<<endl;
            int tyleA=0;
            int tyleC=0;
            int tyleG=0;
            int tyleT=0;
            for(int y=0;y<teraz.size();y++)
            {
                if(teraz[y]=='A')
                {
                    tyleA++;
                }
                else if(teraz[y]=='C')
                {
                    tyleC++;
                }
                else if(teraz[y]=='T')
                {
                    tyleT++;
                }
                else if(teraz[y]=='G')
                {
                    tyleG++;
                }
            }
            A.ileA=tyleA;
            A.ileC=tyleC;
            A.ileG=tyleG;
            A.ileT=tyleT;
            seqstack.push_back(A);
            cout<<A.ileC<<endl;
            cout<<A.ileT<<endl;
            cout<<A.ileG<<endl;
            cout<<A.ileA<<endl;
    }
    int rozmiar = przetwarzane.size()/naglowki.size(); /** chyba git to dzielenie przez naglowki **/
    matryca = new char *[2];
    for (int i=0; i<naglowki.size(); i++)
    {
        matryca[i]= new char [rozmiar];
    }
    for(int i=0; i<naglowki.size(); i++)
    {
        for (int j=0; j<rozmiar; j++)
        {
            matryca[i][j]=' ';
        }
    }
    wynikowa = new float *[rozmiar];
    for(int i=0; i<rozmiar; i++)
    {
        wynikowa[i]= new float [rozmiar];
    }
    for(int i=0; i<rozmiar; i++)
    {
        for (int j=0; j<rozmiar; j++)
        {
            wynikowa[i][j]=2.0;/** wstepnie jest 2, potem sie wymysli wartosc unikalna zeby sie git czytalo czy cos**/
        }
    }
    for(int o=0;o<naglowki.size();o++)
    {
        for (int g=0; g<rozmiar; g++)
        {
            matryca[o][g]=seqstack[o].seq.at(g);
        }
    }

    /**liczenie mutuala dla poszczegolnych kolumn**/

 /*   for(int i=0; i<pairs.size(); i++)
    {
        it = two.find(string(pairs[i]) );
        if ( it != two.end() )
        {
             it->second = it->second + 1.0;
            //dwojki[string(pary[i])]=2.0;
        }
        else
        {
            two[string(pairs[i])]=1.0;
        }
    }

   for (it = two.begin(); it != two.end(); ++it)
        {
            cout << it->first << setw(5) << it->second << endl;
        }
      //  return 0;


    */


    /** pary.erase( unique( pary.begin(), pary.end() ), pary.end() ); **/
    /// to jest mozliwie potrzebne :P

    string first;
    string second;
    float small1=0.0;
    float small2=0.0;
    float wynik=0.0;
    vector <string> pairs; /** wstepnie wymyslilem wektor **/
    map<string, float> two;
    map<string, float>::iterator it;
    /// liczniki dot. ACTG z kolumny i , i+1
    float liczA1, liczC1, liczT1, liczG1 = 0.0; ///liczenie wystapien actg w poszczegolnych kolumnach
    float liczA2, liczC2, liczT2, liczG2 = 0.0;
    for (int i=0; i<rozmiar; i++)
    {
        for(int x=0;x<naglowki.size();x++) /// liczy wystapienia w kolumnie "i"
        {
            if(matryca[x][i]=='A')
            {liczA1=liczA1+1.0;}
            else if(matryca[x][i]=='C')
            {liczC1=liczC1+1.0;}
            else if(matryca[x][i]=='T')
            {liczG1=liczG1+1.0;}
            else if(matryca[x][i]=='G')
            {liczT1=liczT1+1.0;}
        }
        liczA1=liczA1/naglowki.size();
        liczC1=liczC1/naglowki.size();
        liczT1=liczT1/naglowki.size();
        liczG1=liczG1/naglowki.size();
        for (int j=i+1; j<rozmiar; j++)
        {
            for(int x=0;x<naglowki.size();x++)
            {
                first.push_back(matryca[x][i]); /** tutaj robi sie slownik ala pythonowy ktory zbiera pary z danej iteracji: i , j=i+1**/
                first.push_back(matryca[x][j]);
                it = two.find(first);
                if ( it != two.end() )
                {
                    it->second = it->second + 1.0;
                }
                else
                {
                    two[first]=1.0;
                }
                first.clear();
            }
            for (it = two.begin(); it != two.end(); ++it) /** wyznaczanie wspolczynnikow czestosci (np. para AC byla 0.2)**/
            {
                it->second = it->second/naglowki.size();
            }
            for(int x=0;x<naglowki.size();x++)
            {
                if(matryca[x][j]=='A')
                {liczA2=liczA2+1.0;}
                else if(matryca[x][j]=='C')
                {liczC2=liczC2+1.0;}
                else if(matryca[x][j]=='T')
                {liczG2=liczG2+1.0;}
                else if(matryca[x][j]=='G')
                {liczT2=liczT2+1.0;}
            }
            liczA2=liczA2/naglowki.size();
            liczC2=liczC2/naglowki.size();
            liczT2=liczT2/naglowki.size();
            liczG2=liczG2/naglowki.size();
            /// tutaj jeszcze przed czyszczeniem mapy musi zadzialac wyliczenie z wzoru
            for (it = two.begin(); it != two.end(); ++it)
            {
                cout << it->first << setw(5) << it->second << endl;
            }
            two.clear();
            liczA2, liczC2, liczT2, liczG2 = 0.0;
            return 0;
        }
        liczA1, liczC1, liczT1, liczG1 = 0.0;
    }
    for(int i=0; i<rozmiar; i++)
    {
        cout<<i<<" ";
        for (int j=0; j<rozmiar; j++)
        {
            cout<<wynikowa[i][j];
        }
        cout<<endl;
    }
    delete wynikowa;
    delete matryca;
    return 0;
}