/*
	Copyright © 2015 Gluzskiy Alexandr (sss)

    This file is part of Unknown Download Manager (UDM).

    UDM is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 2 of the License, or
    (at your option) any later version.

    UDM is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with UDM.  If not, see <http://www.gnu.org/licenses/>.

*/

#include "main.h"
#include <boost/bind.hpp>

#include <curl/curl.h>

#include "curl_download.h"



module_base::~module_base()
{
}


downloader::downloader()
{
	if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK)
		;//TODO: handle error
}

downloader::~downloader()
{
}

void downloader::on_modules_loaded()
{
}

void downloader::load(core_api *a)
{
	api = a;

	info.name = "curl";
	info.description = "basic http/ftp downloader via libcurl, also example how to write downloader modules";
	info.version = "0.0.0.1draft";
	module_download_ui_element_info_s e;
	e.id = 0;
	e.name = "Url";
	e.type = MODULE_UI_ELEMENT_TYPE_e::UI_STR_;
	info.download_creation_ui.push_back(e);
	e.id = 1;
	e.name = "Download path";
	e.type = MODULE_UI_ELEMENT_TYPE_e::UI_STR_;
	info.download_creation_ui.push_back(e);
	info.on_modules_loaded = boost::bind(&downloader::on_modules_loaded, this); //optional definition of function which is called after all modules loaded
}

const module_info_base &downloader::get_module_info()
{
	return info;
}

void downloader::set_module_settings(const std::map<std::string, setting_s> &settings)
{
	this->settings = settings;
}


int downloader::add_download(std::map<int, std::string> params)
{
	curl_download *d = new curl_download(params, api);
	my_download md;
	std::string download_name;
	{
		auto p1 = params[0].rfind("/");
		if(p1 != std::string::npos)
			md.name = params[0].substr(p1);
	}
	md.curl_d = d;
	int id = 0;
	if(!downloads.empty())
	{
		id = downloads.size();

		md.id = id;
	}
	else
		md.id = 0;

	downloads[id] = md;
	//TODO:
	return id;
}

bool downloader::stop_download(int download_id)
{
	//TODO:
	bool status = downloads[download_id].curl_d->stop();
	if(!status)
	{
		//TODO: handle error
		return false;
	}
	return true;
}

bool downloader::start_download(int download_id)
{
	//TODO:
	bool status = downloads[download_id].curl_d->start();
	if(!status)
	{
		//TODO: handle error
		return false;
	}
	return true;
}

bool downloader::delete_download(int download_id, bool delete_data)
{
	bool status = downloads[download_id].curl_d->delete_download();
	if(!status)
	{
		//TODO: handle errror
		return false;
	}
	else
	{
		downloads[download_id].curl_d = nullptr;
	}
	//TODO:
	return true;
}

bool downloader::execute_action_on_download(int download_id, int action_id)
{
	//TODO:
	return true;
}

std::list<download_s> downloader::get_downloads(std::map<int, std::string> params)
{
	std::list<download_s> l;
	for(auto i : downloads)
		l.push_back(i.second);
	//TODO: fill aditional data fields

	return l;
}

download_s downloader::get_download_info(int download_id, std::map<int, std::string> params)
{
	download_s d = downloads[download_id];
	//TODO: fill additional data fields
	return d;
}

extern "C" module_downloader* udm_downloader_module_load()
{
	return new downloader;
}