#include <unistd.h>
#include <string>
#include <cstring>
#include <vector>
#include <stdio.h>
#include <cstdlib>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <ctime>
#include <map>
#include <sstream>
#include <algorithm>

using namespace std;

#define POST 0
#define GET 1
#define BUF_SIZE 1024
#define PORT_HTTP 80

vector<int> rechercher(char* chaine, char* chaine2)
{
    vector<int> posis;
    char *p = strstr(chaine, chaine2);
    while(p != NULL)
    {
        posis.push_back(p++ - chaine);
        p = strstr(p, chaine2);
    }
    return posis;
}

class Requete
{
    public:
        Requete()
        {
            m_type = POST;
        }
        Requete(const char* site, const char* page, int type=POST)
        {
            m_site = site;
            m_page = page;
            setConnexion(site, PORT_HTTP);
            m_type = type;
        }
        void setType(int type)
        {
            m_type = type;
        }
        void setSite(const char* site)
        {
            m_site = site;
            setConnexion(site, PORT_HTTP);
        }
        void setPage(const char* page)
        {
            m_page = page;
        }
        void ajouter(const char* param, const char* valeur)
        {
            m_parametres.push_back(param);
            m_valeurs.push_back(valeur);
        }
        void ajouter(const char* tout)
        {
            m_tout = tout;
        }
        void setValeur(int id, const char* valeur)
        {
            m_valeurs[id] = valeur;
        }
        void setValeur(const char* param, const char* valeur)
        {
            for(int i=0; i<m_parametres.size(); i++)
                if(m_parametres[i] == param)
                {
                    m_valeurs[i] = valeur;
                    break;
                }
        }
        void setConnexion(const char* site, int port) //en cas de proxy par exemple
        {
            hostent *hostinfo = gethostbyname(site);
            m_sin.sin_addr = *(in_addr *) hostinfo->h_addr;
            m_sin.sin_port = htons(port);
            m_sin.sin_family = AF_INET;
        }
        void setConnexion2(const char* ip, int port) //en cas de proxy par exemple
        {
            m_sin.sin_addr.s_addr = inet_addr(ip);
            m_sin.sin_port = htons(port);
            m_sin.sin_family = AF_INET;
        }
        void setCookies(const char* cookies)
        {
            m_cookies = cookies;
        }
        void envoyer()
        {
            int sock = socket(AF_INET,SOCK_STREAM,0);
            char buffer[2][BUF_SIZE] = { {""}, {""} };
            char str[2][BUF_SIZE] = { {""}, {""} };
            sprintf(str[0], "%s %s HTTP/1.1\r\n", (m_type == POST) ? "POST" : "GET", m_page.c_str());
            strcat(buffer[0], str[0]);
            sprintf(str[0], "Host: %s\r\n", m_site.c_str());
            strcat(buffer[0], str[0]);
            strcat(buffer[0], "User-Agent: Mozilla/5.0 (X11; U; Linux i686; fr; rv:1.9.2.8) Gecko/20100723 Ubuntu/10.04 (lucid) Firefox/3.6.8\r\n");
            strcat(buffer[0], "Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8\r\n");
            strcat(buffer[0], "Accept-Language: fr,fr-fr;q=0.8,en-us;q=0.5,en;q=0.3\r\n");
            strcat(buffer[0], "Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7\r\n");
            strcat(buffer[0], "Keep-Alive: 115\r\n");
            strcat(buffer[0], "Connection: keep-alive\r\n");

            if( !m_cookies.empty() )
            {
                sprintf(str[0], "Cookie: %s\r\n", m_cookies.c_str());
                strcat(buffer[0], str[0]);
            }

            if(m_type == POST)
            {
                strcat(buffer[0], "Content-Type: application/x-www-form-urlencoded\r\n");
                if( !m_tout.empty() )
                    strcat(buffer[1], m_tout.c_str());
                else
                    for(int param=0; param<m_parametres.size(); param++)
                    {
                        sprintf(str[1], "%s=%s", m_parametres[param].c_str(), m_valeurs[param].c_str());
                        if(param > 0)
                            strcat(buffer[1], "&");
                        strcat(buffer[1], str[1]);
                    }

                sprintf(str[0], "Content-Length: %d\r\n", strlen(buffer[1]));
                strcat(buffer[0], str[0]);
            }

            strcat(buffer[0], "\r\n");

            if(m_type == POST)
                strcat(buffer[0], buffer[1]);

            connect(sock,(sockaddr *) &m_sin, sizeof(sockaddr));
            send(sock, buffer[0], strlen(buffer[0]), 0);

            m_retour.clear();
            int nb;
            while((nb = recv(sock, buffer[0], BUF_SIZE-1, 0)) > 0)
            {
                buffer[0][nb] = '\0';
                m_retour += buffer[0];

                if( !rechercher((char*)m_retour.c_str(), "</html>").empty() )
                    break;
            }

            close(sock);
        }

        string getRetour() const
        {
            return m_retour;
        }

        string getPage() const
        {
            return m_page;
        }

    private:
        string m_site;
        string m_page;
        vector<string> m_parametres;
        vector<string> m_valeurs;
        string m_tout;
        sockaddr_in m_sin;
        string m_cookies;
        string m_retour;
        int m_type;
};

string conversion(int x)
{
    ostringstream oss;
    oss << x;
    string y = oss.str();
    return y;
}

void actualiserPage(Requete& req, int id, int page)
{
    string x = "/node/"+conversion(id)+"?page="+conversion(page);
    req.setPage( x.c_str() );
    printf("%d %d\n", id, page);
}

int compterPageTopic(map<string,int> &mymap, Requete& req, bool p)
{
    req.envoyer();
    const string& r = req.getRetour();

    vector<int> posis = rechercher((char*)r.c_str(), "<span class=\"submitted\">");
    vector<int> posis2 = rechercher((char*)r.c_str(), "</span>");

    for(int i=0, j=0; i<posis.size(); i++)
    {
        for(; posis2[j] < posis[i]; j++);
        int k=posis2[j];
        while(r[k--] != ' ');
        const string &pseudo = r.substr(k+2, posis2[j]-k-2);
        mymap[pseudo]++;
    }

    if(p)
    {
        posis = rechercher((char*)r.c_str(), "\" title=\"Aller à la dernière page\"");
        int nbPages = (posis.size() == 2) ? r[posis[1]-1]-'0' : 0;
        return nbPages;
    }
    else
        return 0;
}

void compterTopic(map<string,int>& mymap, Requete& req, int id)
{
    actualiserPage(req, id, 0);
    int nbPages = compterPageTopic(mymap, req, true) + 1;
    for(int page = 1; page < nbPages; page++)
    {
        actualiserPage(req, id, page);
        compterPageTopic(mymap, req, false);
    }
}

struct Machin
{
    string str;
    int v;
    Machin() {}
    Machin(string str, int v) : str(str), v(v) {}
    bool operator < (const Machin& M) const
    {
        return v > M.v;
    }
};

int main()
{
    vector<Machin> machins;
    map<string,int> mymap;
    map<string,int>::iterator it;
    Requete req("www.prologin.org","",GET);
    req.setCookies("SESSz099b99b9629cde7986fcdd9b082b95e=d015d1de885f452672ec9c0f86617a3a; has_js=1; __utma=69437137.1587749792.1330733373.1330787804.1330799422.4; __utmc=69437137; __utmz=69437137.1330733373.1.1.utmcsr=(direct)|utmccn=(direct)|utmcmd=(none); __utmb=69437137.11.10.1330799422");

    int nbTopics;
    printf("Dernier topic : ");
    scanf("%d", &nbTopics);
    for(int i=0; i<=nbTopics; i++)
        compterTopic(mymap, req, i);

    for(it=mymap.begin(); it != mymap.end(); it++)
        machins.push_back( Machin(it->first, it->second) );
    sort(machins.begin(), machins.end());

    for(int i=0, j=1; i<machins.size(); i++)
    {
        if(machins[i].v != machins[j-1].v)
            j = i+1;
        printf("%d. %s (%d)\n", j, machins[i].str.c_str(), machins[i].v);
    }

    return 0;
}