#include "Sources.hpp"

#include <iostream>
#include <fstream>
#include <string>
#include <stdexcept>
#include <sstream>

#include <regex.h>
#include <glibmm/regex.h>
#include <giomm.h>
#include <glibmm.h>

using namespace std;
using namespace net::lliurex::apt;



string SourceLine::ToString()
{
	stringstream ss;
	
	ss.str("");
	ss<< ((source_type==SourceType::Deb) ? "deb" : "deb-src");
	ss<<" ";
	
	switch(uri_type)
	{
		case UriType::Http:
			ss<<"http://";
		break;
		
		case UriType::Https:
			ss<<"https://";
		break;
		
		case UriType::Ftp:
			ss<<"ftp://";
		break;
		
		case UriType::File:
			ss<<"file://";
		break;
		
		case UriType::Cdrom:
			ss<<"cdrom:";
		break;
	}
	
	ss<<uri<<" "<<dist;
	
	for(string c : components)
	{
		ss<<" "<<c;
	}
	
	return ss.str();
}

bool SourceLine::IsEqual(SourceLine & line)
{
	bool found=false;
	
	if(source_type==line.source_type && uri_type==line.uri_type
	&& uri==line.uri && dist==line.dist)
	{
		found=true;
		
		for(string c : components)
		{
			bool cfound = false;

			for(string cc : line.components)
			{
				if(cc==c)cfound=true;
			}

			if(!cfound)found=false;
		}
	}
	
	return found;
}


string Sources::str_line="^(?<deb_type>deb|deb\\-src)\\s+(?<uri_type>http://|https://|file://|ftp://|cdrom:)(?<uri>\\[.+\\]/|\\S+)\\s+(?<dist>\\S+)(?<components>(\\s+\\S+)+)";
	
string Sources::str_option="^#(?<key>\\w+)(\\[(?<locale>\\S+)\\])?\\s*=\\s*(?<value>.*)";

const string Sources::SourcesList = "/etc/apt/sources.list";


Sources::Sources()
{

}


Sources::Sources(string filename)
{
	
		
	Glib::RefPtr<Glib::Regex> regex_line = Glib::Regex::create(Sources::str_line);
	Glib::RefPtr<Glib::Regex> regex_option = Glib::Regex::create(Sources::str_option);
	
	ifstream file(filename);
	
	
	optional=false;
	name["C"]="noname";
		
	while(!file.eof())
	{
		string line;
		getline(file,line);//read a single line from the file
		
		Glib::MatchInfo info;
		
		//have we got a match?
		if(regex_line->match(line,info))
		{
			
			string type;
			string uri_type;
			string uri;
			string dist;
			string components;
			vector<string> vcmp;
			
			//fetch matching groups
			type = info.fetch_named("deb_type");
			uri_type=info.fetch_named("uri_type");
			uri=info.fetch_named("uri");
			dist = info.fetch_named("dist");
						
			
			components=info.fetch_named("components");
			
			//split components
			string buf;
			stringstream ss(components.substr(1));
									
			while(ss >> buf)
				vcmp.push_back(buf);
				
			
			//fill SourceLine object
			SourceLine sl;
			
			if(type=="deb")sl.source_type=SourceType::Deb;
			if(type=="deb-src")sl.source_type=SourceType::Source;
			
			if(uri_type=="http://")sl.uri_type=UriType::Http;
			if(uri_type=="https://")sl.uri_type=UriType::Https;
			if(uri_type=="file://")sl.uri_type=UriType::File;
			if(uri_type=="ftp://")sl.uri_type=UriType::Ftp;
			if(uri_type=="cdrom:")sl.uri_type=UriType::Cdrom;
			
			
			//remove all ending slashs
			while(uri[uri.length()-1]=='/')
			{
				uri=uri.substr(0,uri.length()-1);
			}
			
			sl.uri=uri;
			sl.dist=dist;
			
			sl.components = vcmp;
						
			
			//and Push it up
			Push(sl);
		}
		else
		{
			if(regex_option->match(line,info))
			{
				
				string key=info.fetch_named("key");
				string value=info.fetch_named("value");
				string locale=info.fetch_named("locale");
				
				if(key=="optional")
				{
					optional=(value=="true");
				}
				
				if(key=="name")
				{
					locale=(locale=="") ? "C" : locale;
					name[locale]=value;
				}
				
				
			}
		}
	}
	
	file.close();
}


void Sources::Add(string line)
{
	Glib::RefPtr<Glib::Regex> regex_line = Glib::Regex::create(Sources::str_line);
	
	Glib::MatchInfo info;
		

	if(regex_line->match(line,info))
	{
		string type;
		string uri_type;
		string uri;
		string dist;
		string components;
		vector<string> vcmp;
		
		//fetch matching groups
		type = info.fetch_named("deb_type");
		uri_type=info.fetch_named("uri_type");
		uri=info.fetch_named("uri");
		dist = info.fetch_named("dist");
		
		components=info.fetch_named("components");
		
		//split components
		string buf;
		stringstream ss(components.substr(1));
								
		while(ss >> buf)
			vcmp.push_back(buf);
			
		
		//fill SourceLine object
		SourceLine sl;
		
		if(type=="deb")sl.source_type=SourceType::Deb;
		if(type=="deb-src")sl.source_type=SourceType::Source;
		
		if(uri_type=="http://")sl.uri_type=UriType::Http;
		if(uri_type=="https://")sl.uri_type=UriType::Https;
		if(uri_type=="file://")sl.uri_type=UriType::File;
		if(uri_type=="ftp://")sl.uri_type=UriType::Ftp;
		if(uri_type=="cdrom:")sl.uri_type=UriType::Cdrom;
					
		sl.uri=uri;
		sl.dist=dist;
		
		sl.components = vcmp;
					
		
		//and Push it up
		Push(sl);
	}
	else
	{
		throw runtime_error("Failed to parse source line");
	}
	
}


void Sources::Push(SourceLine line)
{

	bool found = false;
	
	for(int n = 0;n<lines.size();n++)
	{
		SourceLine & q = lines[n];
		
		if(q.source_type==line.source_type && q.uri_type==line.uri_type
		 && q.uri==line.uri && q.dist==line.dist)
		 {
		 	found = true;
		 	
		 	for(string component : line.components)
		 	{
		 		bool cfound = false;
		 		
		 		for(string c : q.components)
		 		{
		 			if(c==component)cfound=true;
		 		}
		 		
		 		if(!cfound)
		 		{
		 			q.components.push_back(component);
		 		}
		 	}
		 }
	}
	
	if(!found)
	{
		lines.push_back(line);
	}
}


FindLineStatus Sources::Find(SourceLine line)
{
	
	int f=0;
	int p=0;
	int nf=0;
	
	for(int n=0;n<lines.size();n++)
	{
		SourceLine & q = lines[n];
		
		bool found=false;
		bool partial=false;
		
		
		if(q.source_type==line.source_type && q.uri_type==line.uri_type
		&& q.uri==line.uri && q.dist==line.dist)
		{
			found=true;
			partial=true;
			
			for(string c : q.components)
			{
				bool cfound=false;
				
				for(string cc : line.components)
				{
					if(cc==c)cfound=true;
				}
				
				if(!cfound)found=false;
			}
		}
		
		if(found)
		{
			f++;
		}
		else
		{
			if(partial)
			{
				p++;
			}
			else
			{
				nf++;
			}
		}
	}
	
	
	FindLineStatus ret;
	
	if(f>0)
	{
		ret=FindLineStatus::Found;
	}
	else
	{
		if(p>0)
		{
			ret=FindLineStatus::Partial;
		}
		else
		{
			ret=FindLineStatus::NotFound;
		}
	}
	
	return ret;
}

Sources net::lliurex::apt::operator+(Sources & A,Sources & B)
{
	Sources R;
	
	
	R.lines = A.lines;
	
	for(SourceLine line : B.lines)
	{
		R.Push(line);
	}
	
	return R;
}


void Sources::Print()
{

	
	for(int n=0;n<lines.size();n++)
	{
		SourceLine & q = lines[n];

		cout<<q.ToString()<<endl;

	}
}


void Sources::Write(string filename)
{

	ofstream file;
	string out;
	string err;
	int ret;
	
	file.open("/tmp/llx-apt-sources.list");

	for(int n=0;n<lines.size();n++)
	{
		SourceLine & q = lines[n];

		file<<q.ToString()<<endl;

	}

	file.close();
	
	Glib::spawn_command_line_sync("llx-apt-backend /tmp/llx-apt-sources.list "+filename,&out,&err,&ret);

		
	
	if(ret!=0)
	{
		cout<<"output:"<<endl;
		cout<<out<<endl;
	
		cout<<"err:"<<endl;
		cout<<err<<endl;
		throw std::runtime_error("Failed to write "+filename);
	}
}