/*
 * Copyright 2004-2008, François Revol, <revol@free.fr>.
 * Distributed under the terms of the MIT License.
 */

#include <OS.h>
#include <KernelExport.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <malloc.h>
#include <sys/socket.h>
#include "duckduckgo_request.h"

#include "websearchfs.h"
#include "lists2.h"
#include "settings.h"
#include "string_utils.h"

#include <UrlProtocolRoster.h>
#include <UrlRequest.h>

using namespace BPrivate::Network;

#define DO_PUBLISH
//#define FAKE_INPUT "/boot/home/devel/drivers/websearchfs/log2.html"

#define TESTURL "http://www.duckduckgo.com/search?hl=en&ie=UTF-8&num=50&q=beos"
#define BASEURL "https://html.duckduckgo.com/html/?kd=-1"
        // kd=-1 disables redirection of all URLs through duckduckgo servers
#define FMT_NUM "&num=%u"
        // TODO remove this, duckduckgo does not have this option
#define FMT_Q "&q=%s"

/* parse_duckduckgo_html.c */
extern int duckduckgo_parse_results(const char *html, size_t htmlsize, long *nextid, struct duckduckgo_result **results);


status_t duckduckgo_request_process(struct duckduckgo_request *req)
{
        struct BUrlRequest *cnx = NULL;
        struct duckduckgo_result *res;
        status_t err;
        int count;
        char *p = NULL;
        char *url = NULL;
        BMallocIO output;
        thread_id t;
        
        err = ENOMEM;
        req->cnx = cnx;
#ifndef FAKE_INPUT
        p = urlify_string(req->query_string);
        if (!p)
                goto err_con;
        
        err = ENOMEM;
        url = (char*)malloc(strlen(BASEURL)+strlen(FMT_NUM)+10+strlen(FMT_Q)+strlen(p)+2);
        if (!url)
                goto err_url;
        strcpy(url, BASEURL);
        sprintf(url+strlen(url), FMT_NUM, (unsigned int)max_results);
        sprintf(url+strlen(url), FMT_Q, p);
        
        fprintf(stderr, "duckduckgo_request: final URL: %s\n", url);
        
        cnx = BUrlProtocolRoster::MakeRequest(url, &output, NULL);
        if (cnx == NULL)
                return ENOMEM;

        t = cnx->Run();
        wait_for_thread(t, &err);
        
        fprintf(stderr, "duckduckgo_request: buffer @ %p, len %ld\n", output.Buffer(), output.BufferLength());
        {
                int fd;
                // debug output
                fd = open("/tmp/duckduckgo.html", O_CREAT|O_TRUNC|O_RDWR, 0644);
                write(fd, output.Buffer(), output.BufferLength());
                close(fd);
        }
#else
        {
                int fd;
                struct stat st;
                // debug output
                fd = open(FAKE_INPUT, O_RDONLY, 0644);
                if (fd < 0)
                        return -1;
                if (fstat(fd, &st) < 0) {
                        close(fd);
                        return -1;
                }
                cnx->datalen = st.st_size;
                cnx->data = malloc(cnx->datalen);
                if (!cnx->data)
                        return ENOMEM;
                if (read(fd, cnx->data, cnx->datalen) < cnx->datalen)
                        return -1;
                close(fd);
        }
#endif /* FAKE_INPUT */ 
        err = count = duckduckgo_parse_results((const char*)output.Buffer(), output.BufferLength(),
                &req->nextid, &req->results);
        if (err < 0)
                goto err_get;
#ifdef DO_PUBLISH
        while ((res = SLL_DEQUEUE(req->results, next))) {
                res->next = NULL;
                websearchfs_push_result_to_query(req, res);
        }
#endif
        free(url);
        free(p);
        // request is kept and deleted in duckduckgo_request_close
        return B_OK;


err_get:
        free(url);
err_url:
        free(p);
err_con:
        delete cnx;
        req->cnx = NULL;
        return err;
}

status_t duckduckgo_request_process_async(struct duckduckgo_request *req)
{
        return ENOSYS;
}

status_t duckduckgo_request_close(struct duckduckgo_request *req)
{
        if (!req)
                return EINVAL;
        if (!req->cnx)
                return B_OK;
        delete(req->cnx);
        req->cnx = NULL;
        return B_OK;
}

status_t duckduckgo_request_open(const char *query_string, struct fs_volume *volume, struct fs_node *query_node, struct duckduckgo_request **req)
{
        struct duckduckgo_request *r;
        if (!req)
                return EINVAL;
        r = (duckduckgo_request*)malloc(sizeof(struct duckduckgo_request));
        if (!r)
                return ENOMEM;
        memset(r, 0, sizeof(struct duckduckgo_request));
        r->query_string = strdup(query_string);
        r->volume = volume;
        r->query_node = query_node;
        *req = r;
        return B_OK;
}

status_t duckduckgo_request_free(struct duckduckgo_request *req)
{
        if (!req)
                return EINVAL;
        free(req->query_string);
        free(req);
        return B_OK;
}