#ifndef _Valwrapper_wsk
#define _Valwrapper_wsk
int timestamp();
#define vwtrace() writefile("valwrapperlog.txt",ctostr(__LINE__));\
//#include "sflib.cpp"
#include <wininet.h>
#include <windows.h>
#include <winsock2.h>
#include "varlist.h"
#include "filestream.h"

#define ctocp(s)  (char*)s.c_str()
#define pause() cout<<"\npress any key...";getch();cout<<"\r                \r";
#define BAD_SOCK(sock) \
  wsa_error = GetLastError(); \
  closesocket(sock); \
  WSACleanup(); \
  return ;
#define BAD_SOCK_DL(sock) \
  wsa_error = GetLastError(); \
  closesocket(sock); \
  WSACleanup(); \
  return ;
static filestream vallog("valwrapperlog.txt");

class valwrapper{
    private:
    DWORD wsa_error;
    void cutheaders();
    void ws_request(char *prot,char *host, unsigned short port, char *uri, char *referer, char * postdat);
    void ws_dl_request(char *prot,char *host, unsigned short port, char *uri, char *referer, char *filename, char*postdat);
    int tim_hold;

    public:
    int last_time;
    int last_size;
    int lastdl_size;
    int tot_pages;
    varlist cookies;
    valwrapper(string fname);
    unsigned short vwproxport;
    string headers,domain,whole;
    string name, pass, cursource, cooks, vwproxy;
    bool usecooks,savesource,useproxy,superspeed,cookiexport,autolocate;
    string parseheaders(); // returns Location: value
    void getcookies();
    void get(string fname, string referer);
    void post(string fname, string data,string referer);
    void init(string dom);
    void getdl(string fname, string file,string referer);
    void savecookies(string fname,bool clear);
    void loadcookies(string fname,string cfname);
    int recv_for(SOCKET&,int,char*,int&);
    int vt_s();
    int vt_e();



};
int valwrapper::vt_s(){
    tim_hold=timestamp();
    return tim_hold;
}
int valwrapper::vt_e(){
    int i = timestamp();
    last_time = i-tim_hold;
    return last_time;
}


#define SNPOS string::npos
/* utility methods */
string readpass(string pr){
    cout << pr << "==>";
    string ret;
    char n;
    cin.clear();
    //if(cin.peek()!=EOF)cin.ignore(numeric_limits<streamsize>::max(), '\n');
    while(1){
        n=getch();
        if(n=='\b' && ret.length()>0){
            ret.erase(ret.length()-1);
            cout << "\b \b";
        }
        if(n=='\r')break;
        ret+=n;
        cout << "*";
    }
    cout << endl;
    return ret;
}

string ctostr(int i){
    char a[33];
    itoa(i,a,10);
    return a;
}
int cctoint(string s){
    if(s=="0")return 0;
    if(s=="")return -1;
    int i;
    while((i=s.find(",",0))!=SNPOS){
        s.erase(i,1);
    }
    int t = atoi(ctocp(s));
    return (t==0?-1:t);
}

int ctoint(string s){
    if(s=="0")return 0;
    int t = atoi(ctocp(s));
    return (t==0?-1:t);
}

bool instr(string o,string t){
  if(o.find(t)!= SNPOS)return true;
  return false;
}
int findlast(string w,string p,int ind=0){
    int i = w.rfind(p,ind);
    if(i== SNPOS) return -1;
    return i;
}
int findlastl(string w,string p,int ind=0){
    int i = w.rfind(p,ind);
    if(i== SNPOS) return -1;
    return i+p.length();
}
int findnext(string w,string p,int ind = 0){
    int i = w.find(p,ind);
    if(i== SNPOS) return -1;
    return i;
}
int findnextl(string w, string p, int ind = 0){
    int i = w.find(p,ind);
    if(i== SNPOS) return -1;
    return i+p.length();
}
string getbetweeni(string w,string s, string e,int &ind){
    int o = w.find(s,ind);
    int t=w.find(e,o+s.length());
    ind=t;
    if(o == SNPOS || t == SNPOS || o==t) return "";
    o+=+s.length();
    return w.substr(o,t-o);
}
string getbetween(string w, string s, string e,int ind =0){
    int o = w.find(s,ind);
    int t=w.find(e,o+s.length());
    if(o == SNPOS || t == SNPOS || o==t) return "";
    o+=+s.length();
    return w.substr(o,t-o);
}
string getbetween(string w, int s, string e){
    int t=w.find(e,s);
    if( t == SNPOS) return "";
    return w.substr(s,t-s);
}
string getafter(string w, string p,int i=0){
    int t = w.find(p,i);
    if(t==SNPOS)return "";
    return w.substr(t + p.length());
}

void valwrapper::get(string fname,string referer=""){
    tot_pages++;
    if(!instr(fname,"/")) fname = "/"+fname;
    getcookies();
    if(referer != "") referer = "\r\nReferer: "+referer;
    ws_request("GET",ctocp(domain), 80, ctocp(fname), ctocp(referer),"");
    string loc = parseheaders();
    if(autolocate && loc != ""){autolocate = false; get(loc); autolocate = true;}

}
void valwrapper::post(string fname, string data, string referer=""){
    tot_pages++;
    if(!instr(fname,"/")) fname = "/"+fname;
    getcookies();
    if(referer != "") referer = "\r\nReferer: "+referer;
    ws_request("POST",ctocp(domain), 80, ctocp(fname), ctocp(referer), ctocp(data));
    string loc = parseheaders();
    if(autolocate && loc != ""){autolocate = false; get(loc); autolocate = true;}
}
void valwrapper::init(string dom){
    domain = dom;
    //cookies.fillfromfile("systemfiles\\"+domain+".di");
    usecooks = true;
}
void valwrapper::savecookies(string fname,bool clear=false){
    cookies.tofile("system\\"+fname,clear);
}
void valwrapper::loadcookies(string fname,string cfname=""){
    if(cfname != "") savecookies(cfname);
    cookies.clear();
    cookies.fillfromfile(fname);
}

void valwrapper::getdl(string fname, string file, string referer=""){
    if(!instr(fname,"/")) fname = "/"+fname;
    getcookies();
    if(referer != "")
        referer = "\r\nReferer: "+referer;
    ws_dl_request("GET",ctocp(domain),80,ctocp(fname),ctocp(referer),ctocp(file),"");
    parseheaders();
}
valwrapper::valwrapper(string fname=""){
    init(fname);
    usecooks = true;
    savesource = false;
    useproxy = false;
    superspeed = false;
    cookiexport = true;
    tot_pages=0;
}
string valwrapper::parseheaders(){
    if(usecooks){
        string val,names;
        int ind = 0;
        while(true){
            ind = findnext(headers,"Set-Cookie: ",ind+16);
            if( ind == -1) break;
            name = getbetween(headers, "Set-Cookie: ","=",ind-3);
            val = getbetween(headers, "=", ";",ind);
            cookies.set(name,val);
            //pause();
        }
        if(cookiexport)
        cookies.tofile("system\\"+domain+".di",false,"\n");
    }
    if(autolocate){
        int ind = findnextl(headers,"Location: ",0);
        if(ind == -1)return "";
        string val = getbetween(headers,"Location: ","\r\n");
        //cout << headers<<endl;
        //cout << "reloc: "<<val<<endl;
        return val;

    }
    return "";

}
void valwrapper::getcookies(){
    if(!usecooks)return;
    string temp;
    string ret = "Cookie: ";
    ret+=cookies.tostring("=","; ");

//    for(int i = 0; i < cookies.length(); i++){
//        cout << "grabbing cookie" << i<<endl;
//        temp = cookies.get(i);
//        if(temp == "")continue;
//        ret += temp;
//        if(i+1 != cookies.length())ret+="; ";
//    }
    cooks = ret;
}
void valwrapper::cutheaders(){

    whole = cursource;
    int ind = findnext(cursource,"\r\n\r\n",0);
    if(ind == -1){
        headers = cursource;
        return;
    }
    headers = cursource.substr(0,ind);
    ind += 4;
    cursource = cursource.substr(ind);
}
// s = socket to watch, secs is seconds to wait before returning, nret is address of number of bytes read, and tim is address of value of time it took to return
//int valwrapper::recv_for(SOCKET &s,int secs,char *data,int &tim){
//    vt_s();
//    int nret=0;
//    struct timeval timev;
//    fd_set rfds1;
//    timev.tv_sec=secs;
//    FD_ZERO (&rfds1);
//    timev.tv_usec=0;
//    int l = 0;
//    FD_ZERO (&rfds1);
//    if(select ((int)s, &rfds1, NULL, NULL, &timev)) {
//         l = recv(s,data,sizeof(data),0);
//         nret = l;
//         tim=vt_e();
//         return nret;
//    }
//
////    nret = -1;
//    tim=vt_e();
//    return -1;
//}


int valwrapper::recv_for(SOCKET &s,int secs,char *data,int &tim){
vwtrace();
    vt_s();
vwtrace();
    int nret=0;
vwtrace();
    struct timeval timev;
vwtrace();
    fd_set rfds1;
vwtrace();
    timev.tv_sec=secs;
vwtrace();
    FD_ZERO (&rfds1);
vwtrace();
    timev.tv_usec=0;
vwtrace();
    int l = 0;
vwtrace();
    FD_ZERO (&rfds1);
vwtrace();
    if(select ((int)s, &rfds1, NULL, NULL, &timev)) {
vwtrace();
         l = recv(s,data,512,0);
vwtrace();
         nret = l;
vwtrace();
         tim=vt_e();
vwtrace();
         return nret;
vwtrace();
    }
vwtrace();

vwtrace();
//    nret = -1;
vwtrace();
    tim=vt_e();
vwtrace();
    return -1;
vwtrace();
}
/*
void valwrapper::ws_request_old(
        char *prot,
        char *host,
        unsigned short port,
        char *uri,
        char *referer,
        char *postdat)
{
  WSADATA wsaData;
  struct hostent *target_ptr;
  struct sockaddr_in sin;
  SOCKET sock;
  char   req[] = "%s %s HTTP/1.0\r\nHost: %s%s\r\nContent-Length: %s\r\nContent-Type: application/x-www-form-urlencoded\r\nConnection: close\r\n%s\r\n\r\n%s";
  char   *httprequest;
  char   *recv_string;
  char   data[512];
  unsigned long bytes_received;
  unsigned short nret;
  string l = ctostr(strlen(postdat));
  char* len = ctocp(l);


  if (WSAStartup(MAKEWORD(2,2), &wsaData) < 0) return ;
  if ( (sock = socket(PF_INET, SOCK_STREAM, 0)) == INVALID_SOCKET ) {BAD_SOCK(sock);}
  if ( (target_ptr = gethostbyname(host)) == NULL) {BAD_SOCK(sock);}

  if(useproxy){
    string reuri = "";
    reuri += "http://";
    reuri +=host;
    reuri +=uri;
    uri=ctocp(reuri);
    httprequest = (char*)malloc(strlen(req) + strlen(uri) +strlen(len) + strlen(host) + strlen(referer) +  1 +cooks.length()+strlen(prot)+strlen(postdat) );
    sprintf(httprequest, req,prot, uri, host, referer,len,ctocp(cooks),postdat);
    sin.sin_addr.s_addr = inet_addr(vwproxy.c_str());
    sin.sin_port = htons(vwproxport);
  }
  else{
    httprequest = (char*)malloc(strlen(req) + strlen(uri) +strlen(len) + strlen(host) + strlen(referer) +  1 +cooks.length()+strlen(prot)+strlen(postdat) );
    sprintf(httprequest, req,prot, uri, host, referer,len,ctocp(cooks),postdat);
    memcpy(&sin.sin_addr.s_addr, target_ptr->h_addr, target_ptr->h_length);
    sin.sin_port   = htons(port);
  }
//  cout << "httprequest: "<<httprequest<<endl;
    sin.sin_family = AF_INET;

  if ( (connect(sock, (struct sockaddr *)&sin, sizeof(sin)) ) ) {BAD_SOCK(sock);}

  if ( send(sock, httprequest, strlen(httprequest), 0) == -1 ) {BAD_SOCK(sock);}
  recv_string = (char*)malloc(2);
  strcpy(recv_string, "");
  while ( (nret = recv(sock, data, sizeof(data), 0)) > 0 ) {
    bytes_received += nret;
    if(superspeed && nret)break;
    recv_string = (char*)realloc(recv_string, strlen(recv_string) + nret + 1);
    strncat(recv_string, data, nret);
  }
  closesocket(sock);
  cursource = recv_string;
  cutheaders();
  WSACleanup();
  free(httprequest);
  free(recv_string);
}


*/
void valwrapper::ws_request(
        char *prot,
        char *host,
        unsigned short port,
        char *uri,
        char *referer,
        char *postdat)
{
  WSADATA wsaData;
  struct hostent *target_ptr;
  struct sockaddr_in sin;
  SOCKET sock;
  char   req[] = "%s %s HTTP/1.0\r\nHost: %s%s\r\nContent-Length: %s\r\nContent-Type: application/x-www-form-urlencoded\r\nConnection: close\r\n%s\r\n\r\n%s";
  char   *httprequest;
  char   *recv_string;
  char   data[512];
  unsigned long bytes_received;
  unsigned short nret;
  string l = ctostr(strlen(postdat));
  char* len = ctocp(l);


  if (WSAStartup(MAKEWORD(2,2), &wsaData) < 0) return ;
  if ( (sock = socket(PF_INET, SOCK_STREAM, 0)) == INVALID_SOCKET ) {BAD_SOCK(sock);}
  if ( (target_ptr = gethostbyname(host)) == NULL) {BAD_SOCK(sock);}

  if(useproxy){
    string reuri = "";
    reuri += "http://";
    reuri +=host;
    reuri +=uri;
    uri=ctocp(reuri);
    httprequest = (char*)malloc(strlen(req) + strlen(uri) +strlen(len) + strlen(host) + strlen(referer) +  1 +cooks.length()+strlen(prot)+strlen(postdat) );
    sprintf(httprequest, req,prot, uri, host, referer,len,ctocp(cooks),postdat);
    sin.sin_addr.s_addr = inet_addr(vwproxy.c_str());
    sin.sin_port = htons(vwproxport);
  }
  else{
    httprequest = (char*)malloc(strlen(req) + strlen(uri) +strlen(len) + strlen(host) + strlen(referer) +  1 +cooks.length()+strlen(prot)+strlen(postdat) );
    sprintf(httprequest, req,prot, uri, host, referer,len,ctocp(cooks),postdat);
    memcpy(&sin.sin_addr.s_addr, target_ptr->h_addr, target_ptr->h_length);
    sin.sin_port   = htons(port);
  }
//  cout << "httprequest: "<<httprequest<<endl;
    sin.sin_family = AF_INET;

  if ( (connect(sock, (struct sockaddr *)&sin, sizeof(sin)) ) ) {BAD_SOCK(sock);}
  int tot_time=0,temptime,loops=0;
  if ( send(sock, httprequest, strlen(httprequest), 0) == -1 ) {BAD_SOCK(sock);}
  last_size=0;
  //  while(1){
//
//        nret = recv_for(sock,5,data,temptime);
//        tot_time+=temptime;
//        if(nret==-1){
//           if (tot_time>=30000){
//                last_size=0;
//                if(loops==2){
//                    cout << "no good...";
//                    pause();
//                }
//                loops++;
//                if(send(sock,httprequest,strlen(httprequest),0) ==-1){BAD_SOCK(sock);}
//                tot_time=0;
//           }
//        }
//        if(nret==0)break;
//        last_size+=nret;
//        recv_string = (char*)realloc(recv_string, strlen(recv_string) + nret + 1);
//        strncat(recv_string, data, nret);
//
//    }
  recv_string = (char*)malloc(2);
  strcpy(recv_string, "");
  while(1){
            vwtrace();

            vwtrace();
        nret = recv_for(sock,5,data,temptime);
            vwtrace();
        tot_time+=temptime;
            vwtrace();
        if(nret==-1){
            vwtrace();
           if (tot_time>=30000){
            vwtrace();
                last_size=0;
            vwtrace();
                if(loops==2){
            vwtrace();
                    cout << "no good...";
            vwtrace();
                    pause();
            vwtrace();
                }
            vwtrace();
                loops++;
            vwtrace();
                if(send(sock,httprequest,strlen(httprequest),0) ==-1){BAD_SOCK(sock);}
            vwtrace();
                tot_time=0;
            vwtrace();
           }
            vwtrace();
        }
            vwtrace();
        if(nret==0)break;
            vwtrace();
        last_size+=nret;
            vwtrace();
        recv_string = (char*)realloc(recv_string, strlen(recv_string) + nret + 1);
//         cout << strlen(recv_string);
//         cout<<endl <<strlen(data);
//         cout<< endl << nret <<endl;
//
            vwtrace();
        strncat(recv_string, data, nret);
            vwtrace();

            vwtrace();
    }

//  recv_string = (char*)malloc(2);
//  strcpy(recv_string, "");
//  while ( (nret = recv(sock, data, sizeof(data), 0)) > 0 ) {
//    bytes_received += nret;
//    if(superspeed && nret)break;
//    recv_string = (char*)realloc(recv_string, strlen(recv_string) + nret + 1);
//    strncat(recv_string, data, nret);
//  }
  closesocket(sock);
  cursource = recv_string;
  cutheaders();
  WSACleanup();
  free(httprequest);
  free(recv_string);
}
#define Ws_trace(i) ;
// cout << "w "<<i<<" l "<<__LINE__<<"\r";

void valwrapper::ws_dl_request(char * prot,char *host,
        unsigned short port,
        char *uri,
        char *referer,
        char *filename,
        char *postdat)
{
  WSADATA wsaData;
  struct hostent *target_ptr;
  struct sockaddr_in sin;
  SOCKET sock;
  char   req[] = "%s %s HTTP/1.0\r\nHost: %s%s\r\nContent-Type: application/x-www-form-urlencoded\r\nConnection: close\r\n%s\r\n\r\n%s";
  char   *httprequest;
  char   *recv_string;
  char   data[3000];
  unsigned long bytes_received;
  unsigned short nret;
  Ws_trace(1);
  if (WSAStartup(MAKEWORD(2,2), &wsaData) < 0) return ;
  if ( (sock = socket(PF_INET, SOCK_STREAM, 0)) == INVALID_SOCKET ) {BAD_SOCK_DL(sock);}
  if ( (target_ptr = gethostbyname(host)) == NULL) {BAD_SOCK_DL(sock);}
  if(useproxy){
        sin.sin_addr.s_addr = inet_addr(vwproxy.c_str());
        sin.sin_port = htons(vwproxport);
    }
    else{
        memcpy(&sin.sin_addr.s_addr, target_ptr->h_addr, target_ptr->h_length);
        sin.sin_port   = htons(port);
    }
    sin.sin_family = AF_INET;
   Ws_trace(2);
  if ( (connect(sock, (struct sockaddr *)&sin, sizeof(sin)) ) ) {
    BAD_SOCK_DL(sock);
  }
  Ws_trace(3);
  httprequest = (char*)malloc(strlen(req) + strlen(uri) + strlen(host) + strlen(referer) +  1 +cooks.length()+strlen(prot)+strlen(postdat) );
  //char   req[] = "POST %s HTTP/1.0\r\nHost: %s\r\nReferer: %s\r\nContent-Length: %s\r\nContent-Type: application/x-www-form-urlencoded\r\nConnection: close\r\n\r\n%s";
  sprintf(httprequest,req,prot, uri, host, referer,ctocp(cooks),postdat);
  Ws_trace(4);
  if ( send(sock, httprequest, strlen(httprequest), 0) == -1 ) {
    BAD_SOCK_DL(sock);
  }
  Ws_trace(5);
  recv_string = (char*)malloc(2);
  strcpy(recv_string, "");
  FILE *fwt;
  fwt = fopen(filename,"wb");
//  fwm = fopen("recv.di","wb");
  int tmp = 0,tmp2=0,tmp3=2;
  Ws_trace(6);
  while ( (nret = recv(sock, data, 3000, 0)) > 0) {
        recv_string = (char*)realloc(recv_string, tmp + nret + 1);
        memcpy(tmp+recv_string,data,nret);
        tmp+= nret;

    }
    Ws_trace(7);
//    fwrite(recv_string,sizeof(recv_string[0]),sizeof(recv_string),fwm);
//
////  cout << datasize: "<<sizeof(recv_string)<<endl;
//    cout << recv_string << endl;
//    char *ndata;
//    ndata = strstr(recv_string,"\r\n\r\n");
//
////  cout << "tmp: "<<tmp<<endl;
////  cout << "Ndata1: "<<ndata<<endl;
//    ndata=4+ndata;
////  cout << "ndata2: "<<ndata<<endl;
//
//    fwrite(ndata,1,sizeof(ndata),fwt);
//    //
    for(int i = 0; i < tmp-5; i++){
        Ws_trace(12);
        if(recv_string[i] == '\r' && recv_string[i+1] == '\n' && recv_string[i+2] == '\r' && recv_string[i+3] == '\n' )
        {
            Ws_trace(10);
            fwrite(recv_string+i+4, 1, tmp-(i+4),fwt);
            Ws_trace(11);
            lastdl_size=tmp-i;
            break;
        }
    }
    Ws_trace(8);
//
//  fwrite(ndata,sizeof(data[0]),sizeof(data)/sizeof(data[0]),fwt);
  fclose(fwt);
//  fclose(fwm);
  closesocket(sock);
  WSACleanup();
  free(httprequest);
  free(recv_string);
  Ws_trace(9);
}


// comonly used Formatting methods:
    string hex(char n){
    switch (n){
        case ' ':
            return "%20";
        break;
        case '!':
            return "%21";
        break;
        case '#':
            return"%23";
        break;
        case '$':
            return"%24";
        break;
        case '%':
            return "%25";
        break;
        case '^':
            return "%5E";
        break;
        case '&':
            return "%26";
        break;
        case '(':
            return "%28";
        break;
        case ')':
            return "%29";
        break;
        case '=':
            return "%3D";
        break;
        case '+':
            return "%2B";
        break;
        case '[':
            return "%5B";
        break;
        case '{':
            return "%7B";
        break;
        case ']':
            return "%5D";
        break;
        case '}':
            return "%7D";
        break;
        case '\\':
            return "%5C";
        break;
        case '|':
            return "%7C";
        break;case ';':
            return "%3B";
        break;case ':':
            return "%3A";
        break;case '\'':
            return "%27";
        break;case '\"':
            return "%22";
        break;case ',':
            return "%2C";
        break;case '<':
            return "%3C";
        break;case '>':
            return "%3E";
        break;case '/':
            return "%2F";
        break;case '?':
            return "%3F";
        break;case '`':
            return "%60";
        break;case '~':
            return "%7E";
        break;
        default:
            string ret = "";
            ret += n;
            return ret;
        break;
    }
}

string ctoposthex(string text){
    string ret;
    for(int i = 0; i < text.length(); i++){
        ret += hex(text[i]);
    }
    return ret;
}


string ctomysql(string what){
    string ret = "";
    for(int i = 0; i < what.length(); i++){
        if( what[i] == '\''){
            ret += "\\\'";
        }
        else if(what[i] == '\n'){
        }
        else ret += what[i];
    }
    return ret;
}

/*  coppied from online...  select method to make a noneblocking socket

void shell(SOCKET s) {
    struct timeval timev;
    char buff[512];
    fd_set rfds1;
    fd_set rfds2;
    timev.tv_sec=30;
    FD_ZERO (&rfds1);
    FD_ZERO (&rfds2);
    timev.tv_usec=0;
    int l = 0;
    FD_ZERO (&rfds1);
    if(select ((int)s, &rfds1, NULL, NULL, &timev)) {
         //    printf("WOOT\n");
             l = recv(s,buff,sizeof(buff),0);
             write(1,buff,l);
         }



    while(1) {

         FD_ZERO (&rfds2);
         FD_SET (s, &rfds1);
         FD_SET (0, &rfds2);

         if (_kbhit()!=0) {
         //    printf("HEPP\n");
             l = read(fileno(stdin),buff,sizeof(buff));
             send(s,buff,l,0);
         }
         Sleep(1);
            //    if (select ((int)stdin, &rfds2, NULL, NULL, &timev)) {
        //;
            //    }
         //printf("(filtered)");
    }
}
*/





#endif