/*
**	Command & Conquer Generals Zero Hour(tm)
**	Copyright 2025 Electronic Arts Inc.
**
**	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 3 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 General Public License for more details.
**
**	You should have received a copy of the GNU General Public License
**	along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

//
// expimp.cpp
//

#include "stdAfx.h"
#include "transDB.h"
#include "XLStuff.h"
#include "Babylondlg.h"
#include "VerifyTextDlg.h"
#include "Babylon.h"
#include "expimp.h"
#include "direct.h"
#include "fileops.h"
#include "olestring.h"

static char buffer[100*1024];
static char buffer2[100*1024];
static OLECHAR olebuf[100*1024];
static OLECHAR olebuf2[100*1024];
static OLECHAR oletrans[100*1024];

static CBabylonDlg *progress_dlg;
static int progress_count;

static void progress_cb ( void )
{
	progress_count ++;

	if ( progress_dlg )
	{
		progress_dlg->SetProgress ( progress_count );
	}
}

static FILE *cb_file;

static void print_to_file ( const char *text )
{

	fprintf ( cb_file, "\t\t\tString %s\n", text );

}

static void reverseWord ( OLECHAR *fp, OLECHAR *lp )
{
	int first = TRUE;
	OLECHAR f, l;

	while ( TRUE )
	{
		if ( fp >= lp )
		{
			return;
		}

		f = *fp;
		l = *lp;

		if ( first )
		{
			if ( f >= 'A' && f <= 'Z' )
			{
				if ( l >= 'a' && l <= 'z' )
				{
					f = (f - 'A') + 'a';
					l = (l - 'a') + 'A';
				}
			}

			first = FALSE;
		}

		*lp-- = f;
		*fp++ = l;

	}

}


static void translateCopy( OLECHAR *outbuf, OLECHAR *inbuf )
{
	int slash = FALSE;

	{
		static OLECHAR buffer[100*1024];
		OLECHAR *firstLetter = NULL, *lastLetter;
		OLECHAR *b = buffer;
		int formatWord = FALSE;
		OLECHAR ch;

		while ( (ch = *inbuf++))
		{
			if ( ! (( ch >= 'a' && ch <= 'z') || ( ch >= 'A' && ch <= 'Z' )))
			{
				if ( firstLetter )
				{
					if ( !formatWord )
					{
						lastLetter = b-1;
						reverseWord ( firstLetter, lastLetter );
					}
					firstLetter = NULL;
					formatWord = FALSE;
				}
				*b++ = ch;
				if ( ch == '\\' )
				{
					*b++ = *inbuf++;
				}
				if ( ch == '%' )
				{
					while ( (ch = *inbuf++) && !IsFormatTypeChar ( ch ) && ch != '%')
					{
						*b++ = ch;
					}
					*b++ = ch;
				}
			}
			else
			{
				if ( !firstLetter )
				{
					firstLetter = b;
				}

				*b++ = ch;

			}
		}

		if ( firstLetter )
		{
			lastLetter = b-1;
			reverseWord ( firstLetter, lastLetter );
		}

		*b++ = 0;
		inbuf = buffer;

	}



	while( *inbuf != '\0' )
	{

			*outbuf++ = *inbuf++;
	}
	*outbuf= 0;
}


static void writeLabel ( BabylonLabel *label, int row )
{
	PutCell ( row, CELL_LABEL, label->Name (), 0);
	wcscpy ( olebuf, label->Comment());
	EncodeFormat ( olebuf );
	PutCell ( row, CELL_COMMENT,  olebuf, 0);
	wcscpy ( olebuf, label->Context());
	EncodeFormat ( olebuf );
	PutCell ( row, CELL_CONTEXT, olebuf, 0);
	wcscpy ( olebuf, label->Speaker());
	EncodeFormat ( olebuf );
	PutCell ( row, CELL_SPEAKER, olebuf, 0);
	wcscpy ( olebuf, label->Listener());
	EncodeFormat ( olebuf );
	PutCell ( row, CELL_LISTENER, olebuf , 0);
}

static void writeText ( BabylonText *text, int row )
{
	BabylonLabel *label = text->Label ();
	int maxlen = label->MaxLen ();
	OLECHAR buffer[100];

	if ( !maxlen )
	{
		maxlen = 10000;
	}

	wcscpy ( olebuf, text->Get());
	EncodeFormat ( olebuf );
	PutCell ( row, CELL_ENGLISH, olebuf , 0);
	PutCell ( row, CELL_MAXLEN, NULL , maxlen );

	swprintf ( buffer, L"=LEN(%c%d)",'A' + CELL_LOCALIZED -1,  row );
	PutCell ( row, CELL_STRLEN, buffer , 0);
	swprintf ( buffer, L"=IF(%c%d>%c%d,\"Too long!\",\" \")", 'A' + CELL_STRLEN -1,  row, 'A' + CELL_MAXLEN -1,  row );
	PutCell ( row, CELL_LENCHECK ,buffer , 0);
	PutCell ( row, CELL_REVISION , 0, text->Revision ());
	PutCell ( row, CELL_STRINGID , 0, text->ID ());

	writeLabel ( label, row );
}

static int export_trans ( TransDB *db, LangID langid, TROPTIONS *options, void (*cb) (void ), int write )
{
	BabylonLabel *label;
	BabylonText *text;
	Translation *trans;
	ListSearch sh_label, sh_text;
	int count = 0;
	int limit = FALSE;
	int all = TRUE;
	int row;
	LANGINFO	*linfo;

	linfo = GetLangInfo ( langid );

	if ( options->filter == TR_SAMPLE )
	{
		limit = TRUE;
	}
	else if ( options->filter == TR_CHANGES )
	{
		all = FALSE;
	}

	if ( write )
	{
		OLECHAR buffer[100];

		swprintf ( buffer, L"%S", GetLangName ( langid ));
		PutCell ( ROW_LANGUAGE, COLUMN_LANGUAGE,buffer,0);

		swprintf ( buffer, L"%S Translation", GetLangName ( langid ));
		PutCell ( 2, CELL_LOCALIZED,buffer,0);
	}

	row = 3;
	label = db->FirstLabel ( sh_label );

	while ( label )
	{
		int label_written = FALSE;
		text = label->FirstText ( sh_text );
		
		while ( text )
		{
			int export;
			int bad_format = FALSE;
			int too_long = FALSE;

			trans = text->GetTranslation ( langid );

			if ( options->filter == TR_UNSENT )
			{
				export = !text->IsSent ();
			}
			else	if ( options->filter == TR_NONDIALOG )
			{
				export = !text->IsDialog ();
			}
			else if ( options->filter == TR_UNVERIFIED )
			{
					export = text->IsDialog() && text->DialogIsPresent( DialogPath, langid) && !text->DialogIsValid( DialogPath, langid);
			}
			else if ( options->filter == TR_MISSING_DIALOG )
			{
					export = text->IsDialog() && !text->DialogIsPresent( DialogPath, langid);
			}
			else if ( options->filter == TR_DIALOG )
			{
				export = text->IsDialog ();
			}
			else
			{
				if ( ! (export = all) )
				{
					if ( !trans )
					{
						export = TRUE;
					}
					else
					{
						if ( text->Revision () > trans->Revision ())
						{
							export = TRUE;
						}
						else if ( trans->TooLong ( label->MaxLen ()) )
						{
							export = TRUE;
							too_long = TRUE;
						}
						else if ( !trans->ValidateFormat ( text ) )
						{
							export = TRUE;
							bad_format = TRUE;
						}
					}
				}
			}

			if ( export && text->Len () )
			{
				count++;
				if ( cb )
				{
					cb ();
				}

				if ( write )
				{
					static OLECHAR buffer[100*1024];

					if ( !label_written )
					{
						// write out the lable
						//PutSeparator ( row++ );
						//writeLabel ( label, row );
						label_written = TRUE;
					}

					// write out text
					writeText ( text, row );
					if ( text->IsDialog ())
					{
						swprintf  ( buffer, L"%s%S.wav", text->Wave (), linfo->character );
						wcsupr ( buffer );
						PutCell ( row, CELL_WAVEFILE , buffer, 0);
					}

					{
						Translation *trans = text->GetTranslation ( langid );

						if ( langid == LANGID_JABBER || (trans && ( options->include_translations || too_long || bad_format )))
						{
						
							if ( langid == LANGID_JABBER )
							{
								translateCopy ( olebuf, text->Get() );
							}
							else
							{
								wcscpy ( olebuf, trans->Get());
							}

							EncodeFormat ( olebuf );
							PutCell ( row, CELL_LOCALIZED, olebuf, 0);
							if ( bad_format || too_long)
							{
									wcscpy ( olebuf, L"ERROR: " );
									if ( too_long )
									{
										wcscat ( olebuf, L"too long" );
										if ( bad_format )
										{
											wcscat ( olebuf, L"and " );
										}
									}

									if ( bad_format )
									{
										wcscat ( olebuf, L"bad format" );
									}

									PutCell ( row, CELL_COMMENT, olebuf , 0);
							}
						}
					}
					row++;
				}
			}

			text = label->NextText ( sh_text );
		}

		if ( limit && count > 50 )
		{
			break;
		}

		label = db->NextLabel ( sh_label );
	}

	if ( write )
	{
		PutCell ( row, CELL_STRINGID, NULL, -1 );
		PutCell ( ROW_COUNT, COLUMN_COUNT, NULL, count );
	}

	return count;
}


int ExportTranslations ( TransDB *db, const char *filename, LangID langid, TROPTIONS *options, CBabylonDlg *dlg )
{
	int exports ;
	exports = export_trans ( db, langid, options, NULL, FALSE );

	if ( !exports )
	{
		if ( dlg )
		{
			AfxMessageBox ( "Nothing to export." );
			dlg->Ready ();
		}

		return 0;
	}

	if ( (progress_dlg = dlg) )
	{
		char *format;
		dlg->InitProgress ( exports );

		dlg->Log ("");

		switch (options->filter )
		{
			case TR_ALL:
				format = "Exporting all strings";
				break;
			case TR_CHANGES:
				format = "Exporting all strings that require %s translation";
				break;
			case TR_SAMPLE:
				format = "Exporting a sample %s translation file";
				break;
			case TR_DIALOG:
				format = "Exporting dialog only %s translation file";
				break;
			case TR_NONDIALOG:
				format = "Exporting non-dialog %s translation file";
				break;
			case TR_UNVERIFIED:
				format = "Exporting all unverified %s dialog";
				break;
			case TR_MISSING_DIALOG:
				format = "Exporting all missing %s dialog";
				break;


			default:
				format = "Undefined switch";
				break;


		}
		strcpy ( buffer2, format );
		if ( options->include_comments && options->include_translations )
		{
			strcat ( buffer2, " with current %s translations and translator comments" );
		}
		else if ( options->include_comments )
		{
			strcat ( buffer2, " with %s translator comments" );
		}
		else if ( options->include_translations )
		{
			strcat ( buffer2, " with current %s translations" );
		}
		strcat ( buffer2, "..." );
		sprintf ( buffer, buffer2, GetLangName ( langid ), GetLangName ( langid ) );
		dlg->Status ( buffer );
	}

	_getcwd ( buffer, sizeof ( buffer ) -1 );

	strcat ( buffer, "\\babylon.xlt" );

	if ( !FileExists ( buffer ) )
	{
		if ( dlg )
		{
			dlg->Log ("FAILED", SAME_LINE );
			sprintf ( buffer2, "Template file \"%s\" is missing. Cannot export.", buffer );
			AfxMessageBox ( buffer2 );
			dlg->Log ( buffer2 );
			dlg->Ready();
		}
		return -1;
	}

	progress_count = 0;
	exports = -1;

	if ( NewWorkBook ( buffer ) )
	{
		if ( (exports = export_trans ( db, langid, options, progress_cb, TRUE )) != -1 )
		{
			if ( SaveWorkBook ( filename, TRUE ) )
			{
				if ( dlg )
				{
					dlg->Log ("DONE", SAME_LINE );
				}
			}
			else
			{
				if ( dlg )
				{
					dlg->Log ("FAILED", SAME_LINE );
					sprintf ( buffer2, "Failed to save export!");
					AfxMessageBox ( buffer2 );
					dlg->Log ( buffer2 );
				}
				exports = -1;
			}
		}
		CloseWorkBook ( );
	}
	else
	{
		if ( dlg )
		{
			dlg->Log ("FAILED", SAME_LINE );
			sprintf ( buffer2, "Failed to create new work book. File \"%s\" may be corrupt", buffer );
			AfxMessageBox ( buffer2 );
			dlg->Log ( buffer2 );
		}
	}

	if ( dlg )
	{
		dlg->Ready();
	}

	return exports;
}


static int import_trans ( TransDB *db, LangID langid, void (*cb) ( void ), CBabylonDlg *dlg )
{
	int row = 3;
	int id;
	int count = 0;
	int new_count = 0;
	int changes_count = 0;
	int missing_count = 0;
	int mismatch_count = 0;
	int stale_count = 0;
	int	first_mismatch = TRUE;
	int bad_id = FALSE;
	int error_count = 0;
	int revision;

	while ( (id = GetInt ( row, CELL_STRINGID )) != -1)
	{
		if ( id == 0 )
		{
			goto skip;
		}

		BabylonText *text;

		if ( (text = db->FindText ( id )) == NULL )
		{
			// string is no longer in database
			stale_count++;
			goto next;
		}

		revision = GetInt ( row, CELL_REVISION );
				
		if ( text->Revision() > revision )
		{
			// old translation
			stale_count++;
			goto next;
		}

		if ( text->Revision() < revision )
		{
			if ( dlg )
			{
				sprintf ( buffer, "ERROR: expecting revision %d for string ID %d but found revision %d. Possible bad ID!", text->Revision (), id, revision );
				dlg->Log ( buffer );
			}
			error_count++;
			goto next;
		}
				
		// first see if there is any translation there
		GetString ( row, CELL_LOCALIZED, oletrans );
		DecodeFormat ( oletrans );

		if ( !oletrans[0] )
		{
			missing_count++;
			goto next;
		}

		// verify that the translated engish is the same as the current english
		GetString ( row, CELL_ENGLISH, olebuf );
		DecodeFormat ( olebuf );
		
		if ( wcscmp ( text->Get(), olebuf ) )
		{
			// they are two possible reasons for the text to mismatch
			// 1. text was modified but not re-translated
			// 2. the IDs are wrong
			// 
			// to check for the first case we search for the label in the xl file
			// and make sure it is the same. If not then we have problems

			int nrow = row;

			olebuf2[0] = 0;
			while ( nrow > 0 )
			{
				GetString ( nrow, CELL_LABEL, olebuf2 );
				if ( olebuf2[0] )
				{
					break;
				}
				nrow--;
			}


			if ( !olebuf2[0] || wcscmp ( text->Label ()->Name(), olebuf2))
			{
				sprintf ( buffer, "%S", olebuf );
				CVerifyTextDlg dlg(buffer, text->GetSB());

				// didnt find label or label doesn't match 
				// It is possible that the xl was resorted so ask user to do a visual confirmation

				bad_id = dlg.DoModal ()==IDNO;
			} 
			else if ( text->Label()->FindText( olebuf ))
			{
				// we did find the label but text other than the current ID sourced text matches with the import text
				// this means the ID is definitely wrong
				bad_id = TRUE;
			}
			else
			{
				bad_id = FALSE;
			}

			if ( bad_id )
			{
				goto done;
			}

		}

		// ok import the translation

		Translation *trans;
						
		if ( ! (trans = text->GetTranslation ( langid )))
		{
				new_count++;
		
				trans = new Translation	 ();
				trans->SetLangID ( langid );
				text->AddTranslation ( trans );
		}
		
		
		if ( trans->Revision () == revision && !wcscmp ( trans->Get (), oletrans ))
		{
			// already up to date
			goto next;
		}

		trans->Set ( oletrans );
		trans->WaveInfo.SetValid ( FALSE );
		trans->SetRevision ( revision );
		changes_count++;
		

		next:				
				count++;
				
				if ( cb )
				{
					cb ();
				}

		skip:
			row++;
	}

done:

	if ( dlg )
	{
			sprintf ( buffer, "Total found : %d", count );
		dlg->Log ( buffer );

		{
			sprintf ( buffer, "New         : %d", new_count);
			dlg->Log ( buffer );
		}
		{
			sprintf ( buffer, "Updates     : %d", (changes_count - new_count));
			dlg->Log ( buffer );
		}
		if ( missing_count )
		{
			sprintf ( buffer, "Missing     : %d", missing_count );
			dlg->Log ( buffer );
		}
		if ( stale_count )
		{
			sprintf ( buffer, "Unmatched   : %d", stale_count);
			dlg->Log ( buffer );
		}

	}

		if ( bad_id )
		{
			if ( dlg )
			{
				sprintf ( buffer, "Aborting import: BAD IDs");
				dlg->Log ( buffer );
			}

			AfxMessageBox ("The imported translation file has bad string IDs! Fix the string IDs and re-import" );
		}
	return count;
}

static int update_sent_trans ( TransDB *db, LangID langid, void (*cb) ( void ), CBabylonDlg *dlg )
{
	int row = 3;
	int id;
	int count = 0;
	int new_count = 0;
	int matched = 0;
	int unmatched = 0;
	int changed = 0;
	int	first_mismatch = TRUE;
	int bad_id = FALSE;
	int error_count = 0;
	int revision;

	while ( (id = GetInt ( row, CELL_STRINGID )) != -1)
	{
		if ( id == 0 )
		{
			goto skip;
		}

		BabylonText *text;

		if ( (text = db->FindText ( id )) == NULL )
		{
			// string is no longer in database
			unmatched++;
			goto next;
		}

		revision = GetInt ( row, CELL_REVISION );
				
		if ( text->Revision() > revision )
		{
			// old translation
			changed++;
			goto next;
		}

		if ( text->Revision() < revision )
		{
			if ( dlg )
			{
				sprintf ( buffer, "ERROR: expecting revision %d for string ID %d but found revision %d. Possible bad ID!", text->Revision (), id, revision );
				dlg->Log ( buffer );
			}
			error_count++;
			goto next;
		}

				
		// verify that the translated engish is the same as the current english
		GetString ( row, CELL_ENGLISH, olebuf );
		DecodeFormat ( olebuf );
		
		if ( wcscmp ( text->Get(), olebuf ) )
		{
			// they are two possible reasons for the text to mismatch
			// 1. text was modified but not re-translated
			// 2. the IDs are wrong
			// 
			// to check for the first case we search for the label in the xl file
			// and make sure it is the same. If not then we have problems

			int nrow = row;

			olebuf2[0] = 0;
			while ( nrow > 0 )
			{
				GetString ( nrow, CELL_LABEL, olebuf2 );
				if ( olebuf2[0] )
				{
					break;
				}
				nrow--;
			}


			if ( !olebuf2[0] || wcscmp ( text->Label ()->Name(), olebuf2))
			{
				sprintf ( buffer, "%S", olebuf );
				CVerifyTextDlg dlg(buffer, text->GetSB());

				// didnt find label or label doesn't match 
				// It is possible that the xl was resorted so ask user to do a visual confirmation

				bad_id = dlg.DoModal ()==IDNO;
			} 
			else if ( text->Label()->FindText( olebuf ))
			{
				// we did find the label but text other than the current ID sourced text matches with the import text
				// this means the ID is definitely wrong
				bad_id = TRUE;
			}
			else
			{
				bad_id = FALSE;
			}

			if ( bad_id )
			{
				goto done;
			}

		}
		else
		{
			// text is still the same
			text->Sent ( TRUE );
			matched++;

		}

		next:				
				count++;
				
				if ( cb )
				{
					cb ();
				}

		skip:
			row++;
	}

done:

	if ( dlg )
	{
			sprintf ( buffer, "Total found : %d", count );
		dlg->Log ( buffer );

		{
			sprintf ( buffer, "Matched         : %d", matched);
			dlg->Log ( buffer );
		}
		{
			sprintf ( buffer, "Unmatched     : %d", unmatched);
			dlg->Log ( buffer );
		}

		if ( changed )
		{
			sprintf ( buffer, "changed   : %d", changed);
			dlg->Log ( buffer );
		}

	}

		if ( bad_id )
		{
			if ( dlg )
			{
				sprintf ( buffer, "Aborting import: BAD IDs");
				dlg->Log ( buffer );
			}

			AfxMessageBox ("The imported translation file has bad string IDs! Fix the string IDs and re-import" );
		}
	return count;
}

int ImportTranslations ( TransDB *db, const char *filename, CBabylonDlg *dlg )
{
	int imports = -1;

	progress_dlg = dlg;
	if ( dlg )
	{
		dlg->Log ("");
		sprintf ( buffer, "Importing \"%s\"...", filename );
		dlg->Status ( buffer );
	}

	if ( OpenWorkBook ( filename ) )
	{
		int num_strings;
		LANGINFO *info;

		num_strings = GetInt ( ROW_COUNT, COLUMN_COUNT );
		GetString ( ROW_LANGUAGE, COLUMN_LANGUAGE, olebuf );
		sprintf ( buffer, "%S", olebuf );
		info = GetLangInfo ( buffer );

		if ( !info )
		{
			if ( dlg )
			{
				AfxMessageBox ( "Import file is of an unknown language or is not a translation file" );
				dlg->Log ( "FAILED", SAME_LINE );
				dlg->Ready();
			}
			CloseWorkBook ();
			return -1;
		}


		if ( dlg )
		{
			dlg->InitProgress ( num_strings );
			progress_count = 0;
			sprintf ( buffer, "...%s", info->name );
			dlg->Log ( buffer, SAME_LINE );
		}

		imports = import_trans ( db, info->langid, progress_cb, dlg );

		CloseWorkBook ( );
	}
	else
	{
		if ( dlg )
		{
			dlg->Log ("FAILED", SAME_LINE );
			sprintf ( buffer2, "Failed to open \"%s\"", buffer );
			AfxMessageBox ( buffer2 );
			dlg->Log ( buffer2 );
		}
	}

	if ( dlg )
	{
		dlg->Ready();
	}

	return imports;
}

static int generate_Babylonstr ( TransDB *db, const char *filename, LangID langid, GNOPTIONS *options )
{
	int ok = FALSE;
	FILE *file;

	if ( ! ( file = fopen ( filename, "wt" ) ))
	{
		goto error;
	}

	fprintf ( file, "// Generated by %s\n", AppTitle );
	fprintf ( file, "// Generated on %s %s\n\n\n", __DATE__, __TIME__ );

	{
		BabylonLabel *label;
		BabylonText *text;
		Translation *trans;
		ListSearch sh_label, sh_text;

		label = db->FirstLabel ( sh_label );
	
		while ( label )
		{
			text = label->FirstText ( sh_text );
		
			fprintf ( file, "\n\n%s\n", label->NameSB ());
				
			while ( text )
			{
				char *string;

				trans = text->GetTranslation ( langid );

				if ( !trans )
				{
					if ( langid == LANGID_US )
					{
						string = text->GetSB ();
					}
					else
					{
						if ( text->Len ())
						{
							if ( options->untranslated == GN_USEIDS )
							{
								string = buffer2;
								sprintf ( string, "%d", text->ID ());
							}
							else
							{
								string = text->GetSB();
							}
						}
						else
						{
							string = "";
						}
					}
				}
				else
				{
					string = trans->GetSB ();
				}

				if ( text->Len() == 0 )
				{
					string = "";
				}

				fprintf ( file, "\"%s\" %s\n", string, text->WaveSB() );
				text = label->NextText ( sh_text );
			}
	
			fprintf ( file, "END\n" );
			label = db->NextLabel ( sh_label );
		}

		ok = TRUE;
	}
error:

	if ( file )
	{
		fclose ( file );
	}

	return ok;
}

static int writeCSFLabel ( FILE *file, BabylonLabel *label )
{
	int id = CSF_LABEL;
	int len = strlen ( label->NameSB() );
	int strings = label->NumStrings ();

	if ( fwrite ( &id, sizeof ( int ), 1, file ) != 1 )
	{
		return FALSE;
	}

	if ( fwrite ( &strings, sizeof ( int ), 1, file ) != 1 )
	{
		return FALSE;
	}

	if ( fwrite ( &len, sizeof ( int ), 1, file ) != 1 )
	{
		return FALSE;
	}

	if ( !len )
	{
		return FALSE;
	}

	if ( fwrite ( label->NameSB(), len, 1, file ) != 1 )
	{
		return FALSE;
	}

	return TRUE;
}

static int writeCSFString ( FILE *file, OLECHAR *string, char *wave, LANGINFO *linfo )
{
	int id = CSF_STRING;
	int len ;
	int wlen = strlen ( wave );

	if ( wlen )
	{
		id = CSF_STRINGWITHWAVE;
	}
	
	wcscpy ( olebuf, string );
	StripSpaces ( olebuf );
	ConvertMetaChars ( olebuf );
	len = wcslen ( olebuf );

	{
		OLECHAR *ptr = olebuf;

		while ( *ptr)
		{
			*ptr = ~*ptr++;
		}

	}

	if ( fwrite ( &id, sizeof ( int ), 1, file ) != 1 )
	{
		return FALSE;
	}

	if ( fwrite ( &len, sizeof ( int ), 1, file ) != 1 )
	{
		return FALSE;
	}

	if ( len )
	{
		if ( fwrite ( olebuf, len*sizeof(OLECHAR), 1, file ) != 1 )
		{
			return FALSE;
		}
	}
	if ( wlen )
	{
		wlen++;
		if ( fwrite ( &wlen, sizeof ( int ), 1, file ) != 1 )
		{
			return FALSE;
		}
		
		if ( fwrite ( wave, wlen-1, 1, file ) != 1 )
		{
			return FALSE;
		}
		if ( fwrite ( linfo->character, 1, 1, file ) != 1 )
		{
			return FALSE;
		}
	}
	return TRUE;
}

static int generate_csf ( TransDB *db, const char *filename, LangID langid, GNOPTIONS *options )
{
	CSF_HEADER header;
	int header_size;
	int ok = FALSE;
	FILE *file;
	LANGINFO	*linfo = GetLangInfo ( langid);

	if ( ! ( file = fopen ( filename, "w+b" ) ))
	{
		goto error;
	}

	header.id = CSF_ID;
	header.version = CSF_VERSION;
	header.skip = 0;
	header.num_labels = 0;
	header.num_strings = 0;
	header.langid = langid;
	header_size = sizeof ( header );

	fseek ( file, header_size, SEEK_SET );

	{
		BabylonLabel *label;
		BabylonText *text;
		Translation *trans;
		ListSearch sh_label, sh_text;

		label = db->FirstLabel ( sh_label );
	
		while ( label )
		{
			text = label->FirstText ( sh_text );
		
			if ( !writeCSFLabel ( file, label ) )
			{
				goto error;
			}
			header.num_labels++;
				
			while ( text )
			{
				OLECHAR *string;

				trans = text->GetTranslation ( langid );

				if ( !trans )
				{
					if ( langid == LANGID_US )
					{
						string = text->Get ();
					}
					else
					{
						if ( text->Len ())
						{
							if ( options->untranslated == GN_USEIDS )
							{
								string = olebuf2;
								swprintf ( string, L"%d", text->ID ());
							}
							else
							{
								string = text->Get();
							}
						}
						else
						{
							string = L"";
						}
					}
				}
				else
				{
					string = trans->Get ();
				}

				if ( !writeCSFString ( file, string, text->WaveSB (), linfo ) )
				{
					goto error;
				}
				header.num_strings ++;

				text = label->NextText ( sh_text );
			}
	
			label = db->NextLabel ( sh_label );
		}

		fseek ( file, 0, SEEK_SET );
		if ( fwrite ( &header, header_size, 1, file ) != 1 )
		{
			goto error;
		}

		fseek ( file, 0, SEEK_END );

		ok = TRUE;
	}

error:

	if ( file )
	{
		fclose ( file );
	}


	return ok;
}


int GenerateGameFiles ( TransDB *db, const char *filepattern, GNOPTIONS *options, LangID *languages, CBabylonDlg *dlg)
{
	static char filename[2*1024];
	LangID langid;
	int count= 0 ;
	int num;

	if ( dlg )
	{
		LangID *temp = languages;
		num = 0;
		while ( *temp++ != LANGID_UNKNOWN )
		{
			num++;
		}

		dlg->Log ( "" );
		dlg->Status ( "Generating game files:" );
		dlg->InitProgress ( num );
		num = 0;
	}
	while ( (langid = *languages++) != LANGID_UNKNOWN )
	{
		LANGINFO *info;
		TRNREPORT trnreport;
		DLGREPORT dlgreport;
		int dlgwarning;
		int trnwarning;
		int done;

		info = GetLangInfo ( langid );

		sprintf ( filename, "%s_%s.%s", filepattern, info->initials, options->format == GN_BABYLONSTR ? "str" : "csf" );
		strlwr ( filename );

		if ( dlg )
		{
			sprintf ( buffer, "Writing: %s  - %s...", filename, GetLangName ( langid ));
			dlg->Status ( buffer );
			dlgwarning = db->ReportDialog ( &dlgreport, langid );
			trnwarning = db->ReportTranslations ( &trnreport, langid );
		}


		if ( options->format == GN_BABYLONSTR )
		{
			done = generate_Babylonstr ( db, filename, langid, options );
		}
		else
		{
			done = generate_csf ( db, filename, langid, options );
		}

		if ( done )
		{
			count++;
			if ( dlg )
			{
				if ( trnwarning || dlgwarning )
				{
					dlg->Log ( "WARNING", SAME_LINE );

					if ( trnwarning )
					{
						int missing;

						if ( (missing = trnreport.missing + trnreport.retranslate) )
						{
							sprintf ( buffer, "%d translation%s missing", missing, missing > 1 ? "s are" : " is" );
							dlg->Log ( buffer );
						}

						if ( trnreport.too_big )
						{
							sprintf ( buffer, "%d string%s too big", trnreport.too_big, trnreport.too_big > 1 ? "s are" : " is" );
							dlg->Log ( buffer );
						}

						if ( trnreport.bad_format )
						{
							sprintf ( buffer, "%d translation%s bad format", trnreport.bad_format, trnreport.bad_format > 1 ? "s have a" : " has a" );
							dlg->Log ( buffer );
						}
					}

					if ( dlgwarning )
					{
						if ( dlgreport.missing )
						{
							sprintf ( buffer, "%d dialog%s missing", dlgreport.missing, dlgreport.missing > 1 ? "s are" : " is" );
							dlg->Log ( buffer );
						}

						if ( dlgreport.unresolved )
						{
							sprintf ( buffer, "%d dialog%s not verified", dlgreport.unresolved, dlgreport.unresolved> 1 ? "s are" : " is" );
							dlg->Log ( buffer );
						}
					}
				}
				else
				{
					dlg->Log ( "OK", SAME_LINE );
				}
			}
		}
		else
		{
			if ( dlg )
			{
				dlg->Log ( "FAILED", SAME_LINE );
			}
		}

		if ( dlg )
		{
			dlg->SetProgress ( ++num );
		}

	}

	if ( dlg )
	{
		dlg->Ready ();
	}
	return count;
}

void ProcessWaves ( TransDB *db, const char *filename, CBabylonDlg *dlg )
{
	int imports = -1;

	progress_dlg = dlg;

	if ( dlg )
	{
		dlg->Log ("");
		sprintf ( buffer, "Processing wavefile \"%s\"...", filename );
		dlg->Status ( buffer );
	}

	if ( OpenWorkBook ( filename ) )
	{
		int row = 1;
		int last_row = 1;
		int matches = 0;
		int unmatched = 0;
		FILE *file = NULL; 
		char *ptr;

		strcpy ( buffer, filename );

		if ( (ptr = strchr ( buffer, '.' )) )
		{
			*ptr = 0;
		}

		strcat ( buffer, ".txt" );

		if ( (file = fopen (buffer, "wt" )))
		{

			while ( row - last_row < 1000 )
			{
				BabylonText *text;

				GetString ( row, 'J' - 'A' + 1, olebuf );

				wcslwr ( olebuf );

				if ( wcsstr ( olebuf, L".wav" ) )
				{
					last_row = row;

					fprintf ( file, "%S : ", olebuf );
					GetString ( row, 'K' -'A' + 1, olebuf );
					StripSpaces ( olebuf );

					if ( (text = db->FindSubText ( olebuf ) ))
					{
						fprintf ( file, "%6d", text->LineNumber () );
					}
					else
					{
						fprintf ( file, "??????" );
					}

					fprintf ( file, " - \"%S\"\n", olebuf );
				}

				row++;
			}

			fclose ( file );
		}

		CloseWorkBook ( );
	}
	else
	{
		if ( dlg )
		{
			dlg->Log ("FAILED", SAME_LINE );
			sprintf ( buffer2, "Failed to open \"%s\"", buffer );
			AfxMessageBox ( buffer2 );
			dlg->Log ( buffer2 );
		}
	}

	if ( dlg )
	{
		dlg->Ready();
	}

}


int GenerateReport ( TransDB *db, const char *filename, RPOPTIONS *options, LangID *languages, CBabylonDlg *dlg)
{
	LangID langid;
	int count= 0 ;
	int num;
	FILE *file = NULL;

	if ( dlg )
	{
		LangID *temp = languages;
		num = 0;
		while ( *temp++ != LANGID_UNKNOWN )
		{
			num++;
		}

		dlg->Log ( "" );
		dlg->Status ( "Generating Report:" );
		dlg->InitProgress ( num );
		num = 0;
	}

	if ( ! ( file = fopen ( filename, "wt" )))
	{
		static char buffer[500];

		sprintf ( "Unable to open file \"%s\".\n\nCannot create report!", filename);
		AfxMessageBox ( buffer );

		if ( dlg )
		{
			dlg->Log ( "FAILED", SAME_LINE );
			dlg->Ready ();
		}
		return 0;
	}

	cb_file = file;

	{
		char date[50];
		char time[50];
		_strtime ( time );
		_strdate ( date );
		fprintf ( file, "Babylon Report: %s %s\n", date, time);
	}



	while ( (langid = *languages++) != LANGID_UNKNOWN )
	{
		LANGINFO *info;
		TRNREPORT tr_report;
		DLGREPORT dlg_report;

		info = GetLangInfo ( langid );

		fprintf ( file, "\n\n%s Status:\n", info->name );


		if ( options->translations )
		{
			int count;

			count = db->ReportTranslations ( &tr_report, langid );
			
			fprintf ( file, "\n\tText Summary: %s\n", info->name );
			fprintf ( file,   "\t-------------\n\n");

			fprintf ( file, "\t\tErrors: %d\n", tr_report.errors);

			if ( langid != LANGID_US )
			{
				fprintf ( file, "\t\tNot translated: %d\n", tr_report.missing);
				fprintf ( file, "\t\tRetranslation: %d\n", tr_report.retranslate);
				fprintf ( file, "\t\tTranslated: %d\n", tr_report.translated );
			}
			fprintf ( file, "\t\tTotal text: %d\n", tr_report.numstrings );

			if ( count && count < options->limit )
			{
				fprintf ( file, "\n\tText Details: %s\n", info->name);
				fprintf ( file,   "\t------------\n\n" );
				db->ReportTranslations ( &tr_report, langid, print_to_file );
			}

		}

		if ( options->dialog )
		{
			int count;

			count = db->ReportDialog ( &dlg_report, langid );
			
			fprintf ( file, "\n\tDialog Summary: %s\n", info->name );
			fprintf ( file,   "\t-------------\n\n");

			fprintf ( file, "\t\tMissing Audio: %d\n", dlg_report.missing);
			fprintf ( file, "\t\tNot verified: %d\n", dlg_report.unresolved);
			fprintf ( file, "\t\tVerified: %d\n", dlg_report.resolved);
			fprintf ( file, "\t\tTotal dialog: %d\n", dlg_report.numdialog );

			if ( count && count < options->limit )
			{
				fprintf ( file, "\n\tDialog Details: %s\n", info->name );
				fprintf ( file,   "\t------------\n\n" );
				db->ReportDialog ( &dlg_report, langid, print_to_file );
			}
		}

		if ( dlg )
		{
			dlg->SetProgress ( ++num );
		}

	}

	if ( dlg )
	{
		dlg->Ready ();
	}

	fclose ( file );

	return count;
}

int UpdateSentTranslations ( TransDB *db, const char *filename, CBabylonDlg *dlg )
{
	int imports = -1;

	progress_dlg = dlg;
	if ( dlg )
	{
		dlg->Log ("");
		sprintf ( buffer, "Importing \"%s\"...", filename );
		dlg->Status ( buffer );
	}

	if ( OpenWorkBook ( filename ) )
	{
		int num_strings;
		LANGINFO *info;

		num_strings = GetInt ( ROW_COUNT, COLUMN_COUNT );
		GetString ( ROW_LANGUAGE, COLUMN_LANGUAGE, olebuf );
		sprintf ( buffer, "%S", olebuf );
		info = GetLangInfo ( buffer );

		if ( !info )
		{
			if ( dlg )
			{
				AfxMessageBox ( "Import file is of an unknown language or is not a translation file" );
				dlg->Log ( "FAILED", SAME_LINE );
				dlg->Ready();
			}
			CloseWorkBook ();
			return -1;
		}


		if ( dlg )
		{
			dlg->InitProgress ( num_strings );
			progress_count = 0;
			sprintf ( buffer, "...%s", info->name );
			dlg->Log ( buffer, SAME_LINE );
		}

		imports = update_sent_trans ( db, info->langid, progress_cb, dlg );

		CloseWorkBook ( );
	}
	else
	{
		if ( dlg )
		{
			dlg->Log ("FAILED", SAME_LINE );
			sprintf ( buffer2, "Failed to open \"%s\"", buffer );
			AfxMessageBox ( buffer2 );
			dlg->Log ( buffer2 );
		}
	}

	if ( dlg )
	{
		dlg->Ready();
	}

	return imports;
}