/*
 * This file part of makedict - convertor from any dictionary format to any
 * http://sdcv.sourceforge.net
 * Copyright (C) 2005 Evgeniy <dushistov@mail.ru>
 *
 * This program 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.
 *
 * This program 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 Library General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */

#ifdef HAVE_CONFIG_H
#  include "config.h"
#endif

#include <cerrno>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <glib/gi18n.h>
#include <glib.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <iostream>
#include <fstream>
#include <vector>
#include <algorithm>
using namespace std;

#include "utils.hpp"

#include "generator.hpp"

class stardict_generator : public makedict_generator {
public:
	stardict_generator()
	{
		set_format("stardict");
		set_version(_("stardict_generator, version 0.2"));
		cur_off=0;
		keys_list.reserve(20000);
	}
	~stardict_generator() 
	{
		for (vector<Key>::iterator p=keys_list.begin(); 
				 p!=keys_list.end(); ++p)
			delete []p->value;
	}
protected:
	int generate(const string& basename, const string& workdir);
	void on_have_data();
private:
	ofstream idx_file;
	fstream tmp_dict_file;
	guint32 cur_off;
	string full_name;

	struct Key {
		char *value;
		guint32 data_off;
		guint32 data_size;
		Key(char *val=NULL, guint32 off=0, guint32 size=0) : 
			value(val), data_off(off), data_size(size)
		{			
		}
		Key(const string& val, guint32 off=0, guint32 size=0) : 
			value(NULL), data_off(off), data_size(size)
		{
			value = new char [val.length()+1];
			strcpy(value, val.c_str());
		}
	};
	vector<Key> keys_list;
	static gint stardict_strcmp(const gchar *s1, const gchar *s2) {
		gint a = g_ascii_strcasecmp(s1, s2);
		if (a == 0)
			return strcmp(s1, s2);
		
		return a;
	}
	class stardict_less {
	public:
		bool operator()(const Key & lh, const Key & rh) {
			return stardict_strcmp(lh.value, rh.value)<0;
		}
	};
	bool create_ifo_file(const string& basename, guint32 wordcount, guint32 idx_file_size);
	string get_current_date(void);
};

int stardict_generator::generate(const string& bname, const string& workdir)
{
	int res=EXIT_FAILURE;
	string basename="stardict-"+bname+"-2.4.2";
	string dirname=workdir+G_DIR_SEPARATOR+basename;

	if (!make_directory(dirname))
		return res;

	string realbasename = dirname+G_DIR_SEPARATOR+bname;

	string file_name=realbasename+".dict.tmp";
	tmp_dict_file.open(file_name.c_str(),
			   ios::binary|ios::out|ios::trunc|ios::in);
	if (!tmp_dict_file) {
		cerr<<_("Can not open/create: ")<<file_name<<endl;      
		return res;
	}
	class remove_after_exit {
	public:
		remove_after_exit(const string& fn) : filename(fn) {}
		~remove_after_exit() {  remove(filename.c_str()); }
	private:
		string filename;
	} rae(file_name);

	file_name=realbasename+".idx";
	idx_file.open(file_name.c_str(), ios::binary|ios::out|ios::trunc);
	if (!idx_file) {
		cerr<<_("Can not open/create: ")<<file_name<<endl;
		return res;    
	}

	file_name=realbasename+".dict";
	ofstream dict_file(file_name.c_str(), ios::binary|ios::out|ios::trunc);
	if (!dict_file) {
		cerr<<_("Can not open/create: ")<<file_name<<endl;
		return res;    
	}

	if (!handle_input())
		return res;

	cout<<_("Sorting...");
	sort(keys_list.begin(), keys_list.end(), stardict_less());
	cout<<_("done\n");

	guint32 wordcount=keys_list.size();
	guint32 data_size, data_offset=0;
	guint32 i=0;

	string encoded_str;
	Key *pitem = &keys_list[i];
	while (i<keys_list.size()) {
		char *prev_item_value=NULL;
		std::vector<char> buf;
		guint32 tmpguint32=0;
		data_size=0;

		for (;;) {
			tmp_dict_file.seekg(pitem->data_off);
			buf.resize(pitem->data_size+1);
			tmp_dict_file.read(&buf[0], pitem->data_size);
			buf[pitem->data_size]='\0';                  

			if (!g_utf8_validate(&buf[0], gssize(-1), NULL)) {
				cerr<<_("Not valid UTF-8 string: ")<<encoded_str<<endl;
				return res;
			}

			if (!dict_file.write(&buf[0], pitem->data_size)) {
				cerr<<_("Can not write in data file\n");
				return res;
			}
      
			data_size+=pitem->data_size;
			prev_item_value=pitem->value;
			++i;
			pitem = &keys_list[i];
			if (i<keys_list.size() && 
			    strcmp(prev_item_value, keys_list[i].value)==0) {
				cerr<<_("Duplicate!: ")<<prev_item_value<<endl;
				wordcount--;
				dict_file.write("\n", 1);
				++data_size;
			} else 
				break;
		}

		idx_file.write(prev_item_value, strlen(prev_item_value)+1);
		tmpguint32 = g_htonl(data_offset);
		idx_file.write((char *)&tmpguint32, sizeof(guint32));
		tmpguint32 = g_htonl(data_size);
		idx_file.write((char *)&tmpguint32, sizeof(guint32));
		data_offset+=data_size;
	}

	if (!create_ifo_file(realbasename, wordcount, idx_file.tellp())) {
		cerr<<_("Creating ifo file error.\n");
		return res;
	}
	cout<<_("Count of articles: ")<<wordcount<<endl;
	res=EXIT_SUCCESS;

	return res;
}

void stardict_generator::on_have_data()
{
	for (std::list<std::string>::iterator p=keys.begin(); p!=keys.end(); ++p)
		keys_list.push_back(Key(*p, cur_off, data.length()));
	tmp_dict_file.write(&data[0], data.length());
	cur_off+=data.length();
}

bool 
stardict_generator::create_ifo_file(const string& basename,  
				    guint32 wordcount, 
				    guint32 idx_file_size)
{
	string filename=basename+".ifo";
	std::ofstream f(filename.c_str(), std::ios::binary|std::ios::out);

	if (!f) {
		cerr<<_("Can not create/open: ")<<filename.c_str()<<endl;
		return false;
	}

	f<<"StarDict's dict ifo file\n"
	 <<"version=2.4.2\n"
	 <<"wordcount="<<wordcount<<"\n"
	 <<"idxfilesize="<<idx_file_size<<"\n";
	if (!full_name.empty())
		f<<"bookname="<<full_name<<"\n";
	else
		f<<"bookname="+dict_info["full_name"]+"\n";
  
	f<<"date="<<get_current_date()<<"\n"
	 <<"sametypesequence=x\n";


	Str2StrTable newline_tbl;
	newline_tbl["\n"]=" ";
	newline_tbl["\r"]=" ";
	string descr;
	replace(newline_tbl, dict_info["description"].c_str(), descr);
	if (!descr.empty())
		f<<"description="<<descr<<"\n";
  
	return true;
}

string stardict_generator::get_current_date(void)
{
  /* Get the current time. */
  time_t curtime = time(NULL);

  /* Convert it to local time representation. */
  struct tm *loctime = localtime (&curtime);
  gchar buf[256];
  strftime(buf, sizeof(buf), "%Y.%m.%d", loctime);
  
  return buf;
}

int main(int argc, char *argv[])
{
	stardict_generator mg;
	return mg.run(argc, argv);
}