namespace Gettext {

using System;
using System.IO;

class GettextBinaryReader {
    private bool clear = false;
    private uint magic = 0; /* switch this to bool as well, to increase speed */

    private Stream  stream; /* stream we're working with: must support seeking and reading (no way?) */
    private uint revision;  /* MO file revision, we don't really pay any attention to this [FIXME] */
    private uint total; /* total number of strings */
    private uint orig; /* offset of table of original strings */
    private uint trans; /* offset of table of translations */
    private string plurals; /* plural forms definition */

    /* Lets read a 4-byte unsigned integer from current position -- not 
       very thread friendly way, we'd need an offset and locking for that */
    private uint readint() {
      byte[] data = new byte[4];
      if (this.clear) {
	uint tmp;
	int count = this.stream.Read(data, 0, 4);
	if (count == 0)
	  throw new Exception(); /* EOF, data could not be read, or whatever */

	if (this.magic == 0x950412de) {
	  return (uint) (data[0] + (data[1]<<8) + (data[2]<<16) + (data[3]<<24));
	} else { /* lets assume that this is so, since clear is ok -- (this.magic == 0xde120495) */
	  return (uint) (data[3] + (data[2]<<8) + (data[1]<<16) + (data[0]<<24));
	}
      } else {
	throw new Exception(); /* not a valid MO file */
      }
    }

    /* Takes a first translation, and extracts value from it.

       It is in the form of one assignment per line, with identifier separated by semicolon from value.

       SOMEWHAT INEFFICIENT, but seldom used, so no big deal!
    */
    private string GetHeaderField (string field) {
      int position, length;
      if (field.Trim() == "") 
	return String.Empty;
      if (this.clear) {

	string header = this.gettext("");
	char[] delim = { '\n' };

	string[] fields = header.Split(delim);
	for (int i=0; i<fields.GetLength(0); i++) {
	  char[] field_delim = { ':' };

	  string[] pair = fields[i].Split(field_delim, 2);

	  
	  if (pair[0].Trim().ToLower() == field.Trim().ToLower())
	    return pair[1].Trim();
	}
      }
      return String.Empty;
    }

    /* Searches for translation of "original" string using binary search.
       Returns translation of string found, or the same string if not found.

       TODO: make use of hash table if it's there. 
       TODO: perhaps improve binary search so that it uses first letter to determine initial positon (i.e. ord(firstletter)-'a'/'z').
    */
    public string gettext(string original) {
      uint start, end, current;
      start = 0; /* we could set it to 1 if we don't want to get translations for "", but that may break stuff */
      end = this.total;

      /* FIXME: Extract "Content-type" header field, and "charset" parameter to determine encoding */
      Text.UTF8Encoding utf8 = new Text.UTF8Encoding();

      current = (start + end)/2;
      if (original == String.Empty)
	current = 0;
      while (start+1 < end) {
	int length, position;

	this.stream.Seek(this.orig + current * 8, SeekOrigin.Begin);
	length = (int)this.readint();
	position = (int)this.readint();

	this.stream.Seek(position, SeekOrigin.Begin);

	byte[] byteorig = new byte[length];
	int result = this.stream.Read(byteorig,0,length);
	
	string message = utf8.GetString(byteorig);
	int comparison = String.Compare(message, original);
	if (comparison == 0) { /* current is what we're looking for */
	  this.stream.Seek(this.trans + current * 8, SeekOrigin.Begin);
	  length = (int)this.readint();
	  position = (int)this.readint();

	  this.stream.Seek(position, SeekOrigin.Begin);
	  byte[] translation = new byte[length];
	  int trresult = this.stream.Read(translation,0,length);

	  return utf8.GetString(translation);

	} else if (comparison < 0) {
	  start = current;
	  current = (start + end)/2;

	} else {
	  end = current;
	  current = (start + end)/2;
	}
      }
      return original;
    }

    /* FIXME: Parse this.plurals, instead of assuming English style */
    public string ngettext(string msg, string msgplural, int n) {

      string key = String.Concat(msg,"\0", msgplural);

      string result = this.gettext(key);
      
      char[] nulls = { '\0' };
      string[] values = result.Split(nulls);
      if (n == 1)
	return values[0];
      else
	return values[1];
    }

    /* Constructor dear to all */
    public GettextBinaryReader(Stream str) {

	this.stream = str;

	if (!(str.CanSeek && str.CanRead))
	    throw new Exception(); /* Stream is not seekable or readable */
	else
	  str.Seek(0,SeekOrigin.Begin);

	byte[] data = new byte[4];
	int count = str.Read(data, 0, 4);
	this.magic = (uint) (data[0] + (data[1]<<8) + (data[2]<<16) + (data[3]<<24));
	

	/* 0xde120495 -- this is other variant for LE machines */
	if (this.magic == 0x950412de || this.magic == 0xde120495) {
	    this.clear = true;

	    this.revision = this.readint();

	    this.total = this.readint();
	    this.orig = this.readint();
	    this.trans = this.readint();

	    this.plurals = this.GetHeaderField("plural-forms");
	    //Console.WriteLine(plurals);

	    /* Read the entire mapping table in memory? */
	} else {
	    this.clear = false;
	    throw new Exception(); /* not a valid MO file */
	}
    }

} /* end of class Gettext */

/* Support for localization of software using GNU gettext compatible mechanisms */
class Localization {

  private string directory; /* base directory to check for translations in, eg. /usr/share/locale */
  private string filename; /* filename with the translation */
  private GettextBinaryReader gt = null;
  private FileStream fs = null;

  public Localization(string domain, string directory) {
    /* FIXME: use $data_prefix/locale for default value, once this is autoconf-ed */
    if (directory == String.Empty) directory = "/usr/share/locale";
    this.directory = directory;

    bool found = false; /* did we find the translation yet? */
    bool cont = true;   /* should looking continue? */
    /* try environment variables LANGUAGE, LC_ALL, LC_MESSAGES, LANG */
    string languages = Environment.GetEnvironmentVariable("LANGUAGE");

    if (languages != null && languages.Trim() != String.Empty) {
      char[] delim = { ':' };
      string[] langs = languages.Trim().Split(delim);
      int i = 0;
      while (!found && i<langs.GetLength(0)) {
	cont = false;
	if (langs[i] != String.Empty) {
	  string current = FindLocale(domain, langs[i]);
	  if (current != String.Empty) {
	    found = true;
	    this.filename = current;
	  }
	}
	i++;
      }
    }

    /* try LC_ALL, LC_MESSAGES, LANG */
    string[] vars = { "LC_ALL", "LC_MESSAGES", "LANG" };
    int j = 0;
    while (cont && !found && j<vars.GetLength(0)) {
      if (!found) {
	string lc = Environment.GetEnvironmentVariable(vars[j]);
	if (lc != null && lc.Trim() != String.Empty) {
	  string current = FindLocale(domain, lc.Trim());
	  if (current != String.Empty) {
	    found = true;
	    this.filename = current;
	  }
	}
      }
      ++j;
    }

    if (found) {
      this.fs = new FileStream(this.filename, FileMode.Open, FileAccess.Read);
      this.gt = new GettextBinaryReader(this.fs);
    } else {
      this.fs = null;
      this.gt = null;
    }
  }

  public string gettext(string msg) {
    if (this.gt != null)
      return this.gt.gettext(msg);
    else
      return msg;
  }

  public string ngettext(string msg, string msgplural, int num) {
    if (this.gt != null)
      return this.gt.ngettext(msg, msgplural, num);
    else
      return msg;
  }

  /* Checks if there's a "domain" translation on "language" */
  private string FindLocale(string domain, string selection) {
    /* "language" is of the form language[_territory[.codeset]][@modifier] */
    /* order: ll_tt.cc@mm, ll_tt@mm, ll@mm and ll */
    /* check GNU libc manual, node "Using gettextized software" */
    string modifier, charset, country, language;
    modifier = charset = country = language = String.Empty;

    int tmp;
    int last = selection.IndexOf('@');
    if (last != -1) {
      modifier = selection.Substring(last+1);
    } else {
      last = selection.Length;
    }

    /* FIXME: Add normalization of charsets */
    tmp = selection.IndexOf('.',0,last-1);
    if (tmp != -1) {
      charset = selection.Substring(tmp+1,last-tmp-1);
      last = tmp;
    }

    tmp = selection.IndexOf('_',0,last-1);
    if (tmp != -1) {
      country = selection.Substring(tmp+1,last-tmp-1);
      last = tmp;
    }
    
    /* FIXME: Add support for aliases /usr/share/locale/locale.alias */
    language = selection.Substring(0,last);

    string result; /* resulting pathname, if found */

    /* ll_CC.CHARSET@Mod */
    string test = ConstructName(language, country, charset, modifier);
    if ((result = this.Exists(domain, test)) != String.Empty)
      return result;

    /* ll_CC@Mod */
    test = ConstructName(language, country, String.Empty, modifier);
    if ((result = this.Exists(domain, test)) != String.Empty)
      return result;

    /* ll@Mod */
    test = ConstructName(language, String.Empty, String.Empty, modifier);
    if ((result = this.Exists(domain, test)) != String.Empty)
      return result;

    /* ll */
    test = ConstructName(language, String.Empty, String.Empty, String.Empty);
    if ((result = this.Exists(domain, test)) != String.Empty)
      return result;
    
    return String.Empty;
  }

  /* Return pathname if a corresponding translation exists */
  private string Exists(string domain, string locale) {
    string filename = String.Concat(domain, ".mo");
    string[] elems = { this.directory, locale, "LC_MESSAGES", filename };
    string path = String.Join("/", elems);

    FileInfo info = new FileInfo(path);
    if (info.Exists)
      return path;
    else
      return String.Empty;
  }

  private string ConstructName(string lang, string country, string charset, string mod) {
    if (lang == String.Empty)
      return String.Empty;

    string result = lang;
    if (country != String.Empty)
      result = String.Concat(result, "_", country);
    if (charset != String.Empty)
      result = String.Concat(result, ".", charset);
    if (mod != String.Empty)
      result = String.Concat(result, "@", mod);
    return result;
  }
} /* end of class Localization */

} /* end of namespace Gettext */