/*
** Copyright 2009 Adrien Destugues, pulkomandy@gmail.com. All rights reserved.
** Distributed under the terms of the MIT License.
*/

#include <PlainTextCatalog.h>

#include <assert.h>
#include <cstdio>
#include <iostream>
#include <fstream>
#include <new>
#include <sstream>
#include <string>

#include <syslog.h>

#include <Application.h>
#include <Directory.h>
#include <File.h>
#include <FindDirectory.h>
#include <fs_attr.h>
#include <Message.h>
#include <Mime.h>
#include <Path.h>
#include <Resources.h>
#include <Roster.h>
#include <String.h>

#include <Catalog.h>


using BPrivate::PlainTextCatalog;
using std::min;
using std::max;
using std::pair;


/*
 *	This file implements the plain text catalog-type for the Haiku
 *	locale kit. It is not meant to be used in applications like other add ons,
 *	but only as a way to get an easy to translate file for developers.
 */


namespace BPrivate {


const char *PlainTextCatalog::kCatMimeType
	= "locale/x-vnd.Be.locale-catalog.plaintext";

static int16 kCatArchiveVersion = 1;
	// version of the catalog archive structure, bump this if you change it!


// Note: \xNN is not replaced back, so you get the unescaped value in the catkey
// file. This is fine for regular unicode chars (B_UTF8_ELLIPSIS) but may be
// dangerous if you use \x10 as a newline...
void
escapeQuotedChars(BString& stringToEscape)
{
	stringToEscape.ReplaceAll("\\", "\\\\");
	stringToEscape.ReplaceAll("\n", "\\n");
	stringToEscape.ReplaceAll("\t", "\\t");
	stringToEscape.ReplaceAll("\"", "\\\"");
}


/*
 * constructs a PlainTextCatalog with given signature and language and reads
 * the catalog from disk.
 * InitCheck() will be B_OK if catalog could be loaded successfully, it will
 * give an appropriate error-code otherwise.
 */
PlainTextCatalog::PlainTextCatalog(const entry_ref &signature,
	const char *language, uint32 fingerprint)
	:
	HashMapCatalog("", language, fingerprint)
{
	// Look for the catalog in the directory we are going to use
	// This constructor is not used so lets disable that...

	fInitCheck = B_NOT_SUPPORTED;
	fprintf(stderr,
		"trying to load plaintext-catalog(lang=%s) results in %s\n",
		language, strerror(fInitCheck));
}


/*
 * constructs an empty PlainTextCatalog with given sig and language.
 * This is used for editing/testing purposes.
 * InitCheck() will always be B_OK.
 */
PlainTextCatalog::PlainTextCatalog(const char *path, const char *signature,
	const char *language)
	:
	HashMapCatalog(signature, language, 0),
	fPath(path)
{
	fInitCheck = B_OK;
}


PlainTextCatalog::~PlainTextCatalog()
{
}


status_t
PlainTextCatalog::ReadFromFile(const char *path)
{
	std::fstream catalogFile;
	std::string  currentItem;

	if (!path)
		path = fPath.String();

	catalogFile.open(path, std::fstream::in);
	if (!catalogFile.is_open()) {
		fprintf(stderr, "couldn't open catalog at %s\n", path);
		return B_ENTRY_NOT_FOUND;
	}

	// Now read all the data from the file

	// The first line holds some info about the catalog :
	// ArchiveVersion \t LanguageName \t AppSignature \t FingerPrint
	if (std::getline(catalogFile, currentItem, '\t').good()) {
		// Get the archive version
		int arcver= -1;
		std::istringstream ss(currentItem);
		ss >> arcver;
		if (ss.fail()) {
	 		// can't convert to int
			fprintf(stderr,
				"Unable to extract archive version ( string: %s ) from %s\n",
				currentItem.c_str(), path);
			return B_ERROR;
		}

		if (arcver != kCatArchiveVersion) {
			// wrong version
			fprintf(stderr,
				"Wrong archive version ! Got %d instead of %d from %s\n", arcver,
				kCatArchiveVersion, path);
			return B_ERROR;
		}
	} else {
		fprintf(stderr, "Unable to read from catalog %s\n", path);
		return B_ERROR;
	}

	if (std::getline(catalogFile, currentItem, '\t').good()) {
		// Get the language
		fLanguageName = currentItem.c_str() ;
	} else {
		fprintf(stderr, "Unable to get language from %s\n", path);
		return B_ERROR;
	}

	if (std::getline(catalogFile, currentItem, '\t').good()) {
		// Get the signature
		fSignature = currentItem.c_str() ;
	} else {
		fprintf(stderr, "Unable to get signature from %s\n", path);
		return B_ERROR;
	}

	if (std::getline(catalogFile, currentItem).good()) {
		// Get the fingerprint
		std::istringstream ss(currentItem);
		uint32 foundFingerprint;
		ss >> foundFingerprint;
		if (ss.fail()) {
			fprintf(stderr, "Unable to get fingerprint (%s) from %s\n",
					currentItem.c_str(), path);
			return B_ERROR;
		}

		if (fFingerprint == 0)
			fFingerprint = foundFingerprint;

		if (fFingerprint != foundFingerprint) {
			return B_MISMATCHED_VALUES;
		}
	} else {
		fprintf(stderr, "Unable to get fingerprint from %s\n", path);
		return B_ERROR;
	}

	// We managed to open the file, so we remember it's the one we are using
	fPath = path;
	// fprintf(stderr, "LocaleKit Plaintext: found catalog at %s\n", path);

	std::string originalString;
	std::string context;
	std::string comment;
	std::string translated;

	while (std::getline(catalogFile, originalString,'\t').good()) {
		// Each line is : "original string \t context \t comment \t translation"

		if (!std::getline(catalogFile, context,'\t').good()) {
			fprintf(stderr, "Unable to get context for string %s from %s\n",
				originalString.c_str(), path);
			return B_ERROR;
		}

		if (!std::getline(catalogFile, comment,'\t').good()) {
			fprintf(stderr, "Unable to get comment for string %s from %s\n",
				originalString.c_str(), path);
			return B_ERROR;
		}

		if (!std::getline(catalogFile, translated).good()) {
			fprintf(stderr,
				"Unable to get translated text for string %s from %s\n",
				originalString.c_str(), path);
			return B_ERROR;
		}

		// We could do that :
		// SetString(key, translated.c_str());
		// but we want to keep the strings in the new catkey. Hash collisions
		// happen, you know. (and CatKey::== will fail)
		SetString(originalString.c_str(), translated.c_str(), context.c_str(),
			comment.c_str());
	}

	catalogFile.close();

#if 0
	uint32 checkFP = ComputeFingerprint();
	if (fFingerprint != checkFP) {
		fprintf(stderr, "plaintext-catalog(sig=%s, lang=%s) "
			"has wrong fingerprint after load (%u instead of %u). "
			"The catalog data may be corrupted, so this catalog is "
			"skipped.\n",
			fSignature.String(), fLanguageName.String(), checkFP,
			fFingerprint);
		return B_BAD_DATA;
	}
#endif

	// some information living in member variables needs to be copied
	// to attributes. Although these attributes should have been written
	// when creating the catalog, we make sure that they exist there:
	UpdateAttributes(path);
	return B_OK;
}


status_t
PlainTextCatalog::WriteToFile(const char *path)
{
	BString textContent;
	BFile catalogFile;

	if (path)
		fPath = path;
	status_t res = catalogFile.SetTo(fPath.String(),
		B_WRITE_ONLY | B_CREATE_FILE | B_ERASE_FILE);
	if (res != B_OK)
		return res;

	UpdateFingerprint();
		// make sure we have the correct fingerprint before we flatten it

	textContent << kCatArchiveVersion << "\t" << fLanguageName.String() << "\t"
		<< fSignature.String() << "\t" << fFingerprint << "\n";

	res = catalogFile.Write(textContent.String(),textContent.Length());
	if (res != textContent.Length())
		return res;

	CatMap::Iterator iter = fCatMap.GetIterator();
	CatMap::Entry entry;
	BString original;
	BString comment;
	BString translated;

	while (iter.HasNext()) {
		entry = iter.Next();
		original = entry.key.fString;
		comment = entry.key.fComment;
		translated = entry.value;

		escapeQuotedChars(original);
		escapeQuotedChars(comment);
		escapeQuotedChars(translated);

		textContent.Truncate(0);
		textContent << original.String() << "\t"
			<< entry.key.fContext.String() << "\t"
			<< comment << "\t"
			<< translated.String() << "\n";
		res = catalogFile.Write(textContent.String(),textContent.Length());
		if (res != textContent.Length())
			return res;
	}

	// set mimetype-, language- and signature-attributes:
	UpdateAttributes(catalogFile);

	return B_OK;
}


/*
 * writes mimetype, language-name and signature of catalog into the
 * catalog-file.
 */
void
PlainTextCatalog::UpdateAttributes(BFile& catalogFile)
{
	// useless on the build-tool-side
}


void
PlainTextCatalog::UpdateAttributes(const char* path)
{
	BEntry entry(path);
	BFile node(&entry, B_READ_WRITE);
	UpdateAttributes(node);
}


BCatalogData *
PlainTextCatalog::Instantiate(const entry_ref &owner, const char *language,
	uint32 fingerprint)
{
	PlainTextCatalog *catalog
		= new(std::nothrow) PlainTextCatalog(owner, language, fingerprint);
	if (catalog && catalog->InitCheck() != B_OK) {
		delete catalog;
		return NULL;
	}
	return catalog;
}


} // namespace BPrivate


extern "C" BCatalogData *
instantiate_catalog(const entry_ref &owner, const char *language,
	uint32 fingerprint)
{
	return PlainTextCatalog::Instantiate(owner, language, fingerprint);
}


extern "C" BCatalogData *
create_catalog(const char *signature, const char *language)
{
	PlainTextCatalog *catalog
		= new(std::nothrow) PlainTextCatalog("emptycat", signature, language);
	return catalog;
}


uint8 gCatalogAddOnPriority = 99;
	// give low priority to this add on, we don't want it to be actually used