/*
 * 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 <glib/gi18n.h>
#include <getopt.h>
#include <unistd.h>
#include <iostream>

#include "utils.hpp"

#include "parser.hpp"

using std::string;
using std::vector;
using std::cout;

int makedict_parser::run(int argc, char *argv[])
{
	static const char *shortopts = "hi";
	static const option lopts[] = {
		{"version", no_argument, NULL, 0 },
		{"help", no_argument, NULL, 'h' },
		{"input-format", no_argument, NULL, 'i'},
		{"is-your-format", required_argument, NULL, 1},
		{"parser-option", required_argument, NULL, 2},
		{ NULL, 0, NULL, 0 },
	};

	int option_index, optc;
	std::string help =
		_("Usage: program path/to/dictionary\n"
			"-h, --help            display this help and exit\n"
			"--version             output version information and exit\n"
			"-i, --input-format    output supported input format and exit\n"
			"--is-your-format file test if file in format which accept this codec\n"
			"--parser-option \"option_name=option_value\"\n");

	while ((optc = getopt_long(argc, argv, shortopts, &lopts[0],
														 &option_index))!=-1) {
		switch (optc) {
		case 'h':
			cout<<help<<std::endl;
			return EXIT_SUCCESS;
		case 0:
			cout<<parser_info["version"]<<std::endl;
			return EXIT_SUCCESS;
		case 1:
			return is_my_format(optarg) ? EXIT_SUCCESS : EXIT_FAILURE;
		case 'i':
			cout<<parser_info["format"]<<std::endl;
			return EXIT_SUCCESS;
		case 2:
			{
				vector<string> l=split(optarg, '=');			
				if (l.size()!=2) {
					std::cerr<<_("Invalid usage of parser-option: didn't find '=' in option")
									 <<std::endl<<help<<std::endl;
					return EXIT_FAILURE;
				}
				str_map::iterator opt_ptr;
				if ((opt_ptr=parser_options.find(l[0]))==parser_options.end()) {
					std::cerr<<_("Invalid parser option, possible options:")<<std::endl;
					for (str_map::iterator it=parser_options.begin(); it!=parser_options.end(); ++it)
						std::cerr<<it->first<<std::endl;
					return EXIT_FAILURE;
				}
				opt_ptr->second=l[1];
			}
			break;
		case '?':
		default:
			std::cerr<<help<<std::endl;
			return EXIT_FAILURE;
		}
	}
	if (optind==argc) {
		cout<<argv[0]<<": "<<_("no input files")<<std::endl;
		return EXIT_FAILURE;
	}
#if 0
	for (str_map::iterator it=parser_options.begin(); it!=parser_options.end(); ++it)
		std::cerr<<it->first<<"\t"<<it->second<<std::endl;
#endif

	int res=parse(argv[optind]);
	// @cip_comment:bug
	//end();
	return res;
}

void makedict_parser::set_parser_info(const std::string& key, const std::string& val)
{
	parser_info[key]=val;
}

void makedict_parser::meta_info()
{
	cout<<"<meta_info>\n";
	str_map::const_iterator p=dict_info.find("icon");
	if (p!=dict_info.end())
		cout<<"<icon>"<<p->second<<"</icon>\n";
	cout<<"</meta_info>\n";
}

inline void makedict_parser::info()
{
	cout<<
		"<xdxf lang_from=\""<<dict_info["lang_from"]<<"\" lang_to=\""<<dict_info["lang_to"]<<"\" format=\"visual\">\n"
		"<full_name>"<<dict_info["full_name"]<<"</full_name>\n"
    "<description>"<<dict_info["description"]<<"</description>\n";
}

void makedict_parser::begin()
{
	meta_info();
	cout<<
		"<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n"
		"<!DOCTYPE xdxf SYSTEM \"http://xdxf.sourceforge.net/xdxf_lousy.dtd\">\n"
		;
	info();
}

void makedict_parser::end()
{
	cout<<
		"</xdxf>\n"
					 <<std::flush;
}

void makedict_parser::set_dict_info(const std::string& key, const std::string& val)
{
	dict_info[key]=val;
}

void makedict_parser::abbrs_begin()
{
	cout<<"<abbreviations>\n";
}

void makedict_parser::abbrs_end()
{
	cout<<"</abbreviations>\n";
}

void makedict_parser::abbr(vector<std::string>& keys, const std::string& val)
{
	cout<<"<abr_def>";
	for (vector<std::string>::iterator p=keys.begin(); p!=keys.end(); ++p)
		cout<<"<k>"<<strip(*p)<<"</k>";
	cout<<"<v>"<<val<<"</v>";
	cout<<"</abr_def>\n";
}

void makedict_parser::article(vector<std::string>& keys, const std::string& val)
{
	cout<<"<ar>";
	for (vector<std::string>::iterator p=keys.begin(); p!=keys.end(); ++p)
		cout<<"<k>"<<strip(*p)<<"</k>\n";
	cout<<val<<"</ar>\n";
}

int makedict_parser::parse(const std::string& url)
{
	return EXIT_SUCCESS;
}

void makedict_parser::remove_not_valid(std::string &str)
{		
	std::string valid_data;	 
	char utf8buf[8];
	for (const char *p=str.c_str(); *p; p=g_utf8_next_char(p)) {
		gunichar ch=g_utf8_get_char(p);
		if (not_valid_chars.find(ch)==not_valid_chars.end()) {
			gint len=g_unichar_to_utf8(ch, utf8buf);
			utf8buf[len]='\0';
			valid_data+=utf8buf;
		}/* else
			std::cerr<<_("Not valid character was removed, its code: ")<<ch<<std::endl;*/
	}
	str=valid_data;
}