//==================================================================================
//==================================================================================
// 
// DATEPROPERTIES-MODUL HAUPTPROGRAMM
// OO-PROGRAMMIERUNG
// AUTOR: DF
// ERSTELLT: 07.04.2004
//
//==================================================================================
//==================================================================================


// ============================================================
// Globale Deklarationen
// ============================================================

// den undefinierten Wert deklarieren
var undefined;


// ============================================================
// Klasse DateProperties
// ============================================================

// ------------------------------------------------------------
// Konstruktor
// ------------------------------------------------------------

// ---------------------------------------
// DateProperties(datum)
// ---------------------------------------
//
// Beschreibung:
// -------------
// Konstruiert ein DatePropertiesObjekt mit optionalen Eigenschaften
//
// Beispiel:
// ---------
// 

function DateProperties(datum, sprache) {  
  // Attribute
  this._datum = undefined;
  this._kw = undefined;
  this._sprache = undefined;
  this._nameKey = undefined;
  this._typKey = undefined;
  this._name = undefined;
  this._nameKurz = undefined;
  this._typ = undefined;
  this._feierTag = undefined;
  // Initialisierungen
  this.datum(datum);
  this.kw(DateProperties.getKalenderWoche(this.datum()));
  this.sprache(sprache);
  this.nameKey(this._getTagNameKey());
  this.typKey(this._getTagTypKey());
  this.name(this._getTagName());
  this.nameKurz(this._getTagNameKurz());
  this.typ(this._getTagTyp());
  var tempObj = this._createFeierTag();
  if (tempObj._istTagFeiertag(this.datum()) != undefined){
    this.feierTag(tempObj);
  }  
}

// ------------------------------------------------------------
// Zugriffsfunktionen
// ------------------------------------------------------------

// -----------
// datum(obj)
// -----------
//
// Beschreibung:
// -------------
//

DateProperties.prototype.datum = function(obj) {
  if (arguments.length) {
    if (! obj instanceof Date) {
      focus();
      throw new Error("ArgumentError:noObjectFromClassDate!");
    }
    this._datum = obj;
  }
  return this._datum;
}

// -----------
// kw(n)
// -----------
//
// Beschreibung:
// -------------
//

DateProperties.prototype.kw = function(n) {
  if (arguments.length) {
    if (!Calendartools.checkNumber(n)) {
      focus();
      throw new Error("ArgumentError:noNumber!");
    }
    this._kw = n;
  }
  return this._kw;
}

// -----------
// sprache(str)
// -----------
//
// Beschreibung:
// -------------
//

DateProperties.prototype.sprache = function(str) {
  if (arguments.length) {
    if (typeof str != "string") {
      focus();
      throw new Error("ArgumentError:noString!");
    }
    this._sprache = str;
  }
  return this._sprache;
}

// -----------
// nameKey(str)
// -----------
//
// Beschreibung:
// -------------
//

DateProperties.prototype.nameKey = function(n) {
  if (arguments.length) {
    if (!Calendartools.checkNumber(n)) {
      focus();
      throw new Error("ArgumentError:noNumber!");
    }
    this._nameKey = n;
  }
  return this._nameKey;
}

// -----------
// typKey(str)
// -----------
//
// Beschreibung:
// -------------
//

DateProperties.prototype.typKey = function(n) {
  if (arguments.length) {
    if (!Calendartools.checkNumber(n)) {
      focus();
      throw new Error("ArgumentError:noNumber!");
    }
    this._typKey = n;
  }
  return this._typKey;
}

// -----------
// name(str)
// -----------
//
// Beschreibung:
// -------------
//

DateProperties.prototype.name = function(str) {
  if (arguments.length) {
    if (typeof str != "string") {
      focus();
      throw new Error("ArgumentError:noString!");
    }
    this._name = str;
  }
  return this._name;
}


// -----------
// nameKurz(str)
// -----------
//
// Beschreibung:
// -------------
//

DateProperties.prototype.nameKurz = function(str) {
  if (arguments.length) {
    if (typeof str != "string") {
      focus();
      throw new Error("ArgumentError:noString!");
    }
    this._nameKurz = str;
  }
  return this._nameKurz;
}

// -----------
// typ(str)
// -----------
//
// Beschreibung:
// -------------
//

DateProperties.prototype.typ = function(str) {
  if (arguments.length) {
    if (typeof str != "string") {
      focus();
      throw new Error("ArgumentError:noString!");
    }
    this._typ = str;
  }
  return this._typ;
}

// -----------
// feierTag(obj)
// -----------
//
// Beschreibung:
// -------------
//

DateProperties.prototype.feierTag = function(obj) {
  if (arguments.length) {
    if (! obj instanceof Feiertag) {
      focus();
      throw new Error("ArgumentError:noObjectFromClassFeiertag!");
    }
    this._feierTag = obj;
  }
  return this._feierTag;
}

// ------------------------------------------------------------
// Private Instanzmethoden
// ------------------------------------------------------------

// ---------------------------------------
// _getTagNameKey()
// ---------------------------------------
//
// Beschreibung:
// -------------
// Methode liefert Key Wochenname des Tages zurück
//
// Beispiel:
// ---------

DateProperties.prototype._getTagNameKey = function() {
  var index = this.datum().getDay();
  return index;
}

// ---------------------------------------
// _getTagTypKey()
// ---------------------------------------
//
// Beschreibung:
// -------------
// Methode liefert Key Typ des Tages zurück
//
// Beispiel:
// ---------

DateProperties.prototype._getTagTypKey = function() {
  var day = this.datum().getDay();
  var index;
  if (day == 0){
    index = 2;
  }
  if (day == 6){
    index = 1;
  }
  if (day != 0 && day != 6){
    index = 0;
  }
  return index;
}

// ---------------------------------------
// _getTagName()
// ---------------------------------------
//
// Beschreibung:
// -------------
// Methode liefert Wochenname des Tages zurück
//
// Beispiel:
// ---------

DateProperties.prototype._getTagName = function() {
  return DateProperties.wochenTageName(this._getTagNameKey(), this.sprache());
}

// ---------------------------------------
// _getTagNameKurz()
// ---------------------------------------
//
// Beschreibung:
// -------------
// Methode liefert Wochenname-Kurzform des Tages zurück
//
// Beispiel:
// ---------

DateProperties.prototype._getTagNameKurz = function() {
  return DateProperties.wochenTageNameKurz(this._getTagNameKey(), this.sprache());
}

// ---------------------------------------
// _getTagTyp()
// ---------------------------------------
//
// Beschreibung:
// -------------
// Methode liefert Typ des Tages zurück
//
// Beispiel:
// ---------

DateProperties.prototype._getTagTyp = function() {
  return DateProperties.tagTypName(this._getTagTypKey(), this.sprache());
}

// -------------------------------------------
// _createFeierTag()
// -------------------------------------------
//
// Beschreibung:
// -------------
// Methode erstell Objekt Feiertag
//
// Beispiel:
// ---------
// _createFeierTag(datumObj);
//

DateProperties.prototype._createFeierTag = function() {
  return Feiertag.createFeiertag({'datum':this.datum()}, {'sprache':this.sprache()});
}

// ------------------------------------------------------------
// Öffentliche Instanzmethoden
// ------------------------------------------------------------

// ------------------------------------------------------------
// Private Klasseneigenschaften
// ------------------------------------------------------------

// ------------------------------------------------------------
// Öffentliche Klasseneigenschaften
// ------------------------------------------------------------

// ------------------------------------------------------------
// Private Klassenmethoden
// ------------------------------------------------------------

// ------------------------------------------------------------
// Öffentliche Klassenmethoden
// ------------------------------------------------------------

// ---------------------------------------
// DateProperties.getKalenderWoche()
// ---------------------------------------
//
// Beschreibung:
// -------------
// Methode liefert Kalenderwoche des Tages zurück
//
// Beispiel:
// ---------

DateProperties.getKalenderWoche_ = function(datumObj) {
  var jahresanfang = new Date(datumObj.getFullYear(),0,1,05,00,00);
  var jahresanfangSec = jahresanfang.getTime();
  var jetzt = new Date(datumObj.getFullYear(),datumObj.getMonth(),datumObj.getDate(),05,00,00);
  jetzt = jetzt.getTime();
  var woTag = jahresanfang.getDay();
  var tempDate = jahresanfangSec;
  if (woTag > 1 && woTag < 5){
    var tempDate = jahresanfangSec + ((7 - woTag) * 24*60*60*1000);
  } else {
    if (woTag < 1){
      var tempDate = jahresanfangSec + ((woTag) * 24*60*60*1000);
    } else {
      var tempDate = jahresanfangSec + ((woTag + (8 - woTag)) * 24*60*60*1000);
    }
  }
  var kw = parseFloat((jetzt - tempDate) / (7*24*60*60*1000));
  var kwVorKomma = parseInt(kw);
  var kwNachKomma = parseFloat(kw - kwVorKomma);
  if (kwNachKomma > 0){
    kwNachKomma = 1;
  }
  kw = parseInt(kwVorKomma + kwNachKomma);
  kw++;  
  return kw;  
}

DateProperties.getKalenderWoche = function(datumObj) {
  var datum=new Date(datumObj.getFullYear(),datumObj.getMonth(),datumObj.getDate()); // Anm. 1
  var jh=datumObj.getFullYear()+1; // Anm. 2
  var kalwo=DateProperties.kaldiff(datum,jh);
  while(kalwo<1) { jh--; kalwo=DateProperties.kaldiff(datum,jh); }
  return kalwo;
}

DateProperties.kaldiff = function(datum,jahr) {
  var d4j=new Date(jahr,0,4);
  var wt4j=(d4j.getDay()+6)%7; // Anm. 3
  var m1wjT=Math.floor(0.01+d4j.getTime()/864e5-wt4j); // Anm. 4
  var datumT=Math.floor(0.01+datum.getTime()/864e5); // Anm. 5
  return Math.floor(1+(datumT-m1wjT)/7); // Anm. 6
}

// -------------------------------------------
// DateProperties.createDatefromTime(time)
// -------------------------------------------
//
// Beschreibung:
// -------------
// Methode erstellt DatumsObjekt von Heute mit bestimmter Uhrzeit
//
// Beispiel:
// ---------
// DateProperties.createDatefromTime(time);
//

DateProperties.createDatefromTime = function(time) {
  var heute = new Date();
  time = time.toString();
  var sek = parseFloat(time.substring(time.length-2, time.length));
  var min = parseFloat(time.substring(time.length-4, time.length-2));
  var std = parseFloat(time.substring(0, time.length-4));
  heute.setSeconds(sek);
  heute.setMinutes(min);
  heute.setHours(std);
  return heute;  
}


// -------------------------------------------
// DateProperties.formatTime(datumObj, formatAngabe)
// -------------------------------------------
//
// Beschreibung:
// -------------
// Methode formatiert ein DatumsObjekt
// Standard = HH:MM:SS
//
// Beispiel:
// ---------
// DateProperties.formatTime(datumObj, 'hhmmss');
//

DateProperties.formatTime = function(datumObj, formatAngabe) {

  var stunde = datumObj.getHours();
  var minute = datumObj.getMinutes();
  var sekunde = datumObj.getSeconds();
  
  if (stunde < 10){
    stunde = '0' + stunde;
  }
  
  if (minute < 10){
    minute = '0' + minute;
  }
  
  if (sekunde < 10){
    sekunde = '0' + sekunde;
  }
  
  return stunde + ':' + minute;
}

// -------------------------------------------
// DateProperties.formatDatum(datumObj, formatAngabe)
// -------------------------------------------
//
// Beschreibung:
// -------------
// Methode formatiert ein DatumsObjekt
// Standard = yyyymmdd
//
// Beispiel:
// ---------
// DateProperties.formatDatum(datumObj, 'yyyymmdd');
//

DateProperties.formatDatum = function(datumObj, formatAngabe, sprache) {
  var jahr = datumObj.getFullYear();
  var monat = datumObj.getMonth();
  monat++;
  if (monat < 10){
    monat = '0' + monat;
  }
  var tag = datumObj.getDate();
  if (tag < 10){
    tag = '0' + tag;
  }
  if (!formatAngabe || formatAngabe == 'yyyymmdd'){
    return jahr + '' + monat + '' + tag;
  }
  if (formatAngabe == 'dd.mm.yyyy'){
    return tag + '.' + monat + '.' + jahr;
  }
  if (formatAngabe == 'yyyy-mm-dd'){
    return jahr + '-' + monat + '-' + tag;
  }
  if (formatAngabe == 'dd.mm'){
    return tag + '.' + monat + '.';
  }
  if (formatAngabe == 'mmmmmm yyyy'){
    return DateProperties.monatName(parseFloat(monat)-1, sprache) + ' ' + jahr;
  }
  if (formatAngabe == 'dd'){
    return tag;
  }
  if (formatAngabe == 'd'){
    return parseFloat(tag);
  }
  return tag + '.' + monat + '.' + jahr;
}

// -------------------------------------------
// DateProperties.addiereAnzahlTageZuDatum(datumObj, AnzahlTage)
// -------------------------------------------
//
// Beschreibung:
// -------------
// Methode  addiert eine Anzahl Tage zu einem Datum
//
// Beispiel:
// ---------
// DateProperties.addiereAnzahlTageZuDatum(datumObj, AnzahlTage);
//

DateProperties.addiereAnzahlTageZuDatum = function(datumObj, AnzahlTage) {
  return new Date(new Date().setTime(datumObj.getTime() + (AnzahlTage * 24 * 60 * 60 * 1000)));
}

// -------------------------------------------
// DateProperties.getMonatAnfangVonDatum(datumObj)
// -------------------------------------------
//
// Beschreibung:
// -------------
// gibt Datum-OBJ vom 1. des Monats von Datum zurück
//
// Beispiel:
// ---------
// DateProperties.getMonatAnfangVonDatum(datumObj);
//

DateProperties.getMonatAnfangVonDatum = function(datumObj) {
  return new Date(datumObj.getFullYear(),datumObj.getMonth(),01,05,00,00); 
}

// -------------------------------------------
// DateProperties.getMonatEndeVonDatum(datumObj)
// -------------------------------------------
//
// Beschreibung:
// -------------
// gibt Datum-OBJ vom letzten des Monats von Datum zurück
//
// Beispiel:
// ---------
// DateProperties.getMonatEndeVonDatum(datumObj);
//

DateProperties.getMonatEndeVonDatum = function(datumObj) {
  var jahr = parseFloat(datumObj.getFullYear());
  var monat = parseFloat(datumObj.getMonth());
  if (monat < 11){
    monat++;
  }
  else{
    monat = 0;
    jahr++;
  }
  var naechsterMonat = new Date(jahr,monat,01,05,00,00);
  ergebnis = new Date(new Date().setTime(naechsterMonat.getTime()-(24*60*60*1000))); 
  return ergebnis;
}

// -------------------------------------------
// DateProperties.monatName(sprache)
// -------------------------------------------
//
// Beschreibung:
// -------------
// Methode liefert Monatname in angeforderter Sprache zurück
// Standard = de
//
// Beispiel:
// ---------
// DateProperties.monatName(3, 'uk');

DateProperties.monatName = function(index, sprache) {
  var monat = {};
  index = parseFloat(index);
  
  monat['de'] = [];
  monat['uk'] = [];
  
  monat['de'][0] = 'Januar';
  monat['de'][1] = 'Februar';
  monat['de'][2] = 'März';
  monat['de'][3] = 'April';
  monat['de'][4] = 'Mai';
  monat['de'][5] = 'Juni';
  monat['de'][6] = 'Juli';
  monat['de'][7] = 'August';
  monat['de'][8] = 'September';
  monat['de'][9] = 'Oktober';
  monat['de'][10] = 'November';
  monat['de'][11] = 'Dezember';
  
  monat['uk'][0] = 'January';
  monat['uk'][1] = 'February';
  monat['uk'][2] = 'March';
  monat['uk'][3] = 'April';
  monat['uk'][4] = 'May';
  monat['uk'][5] = 'June';
  monat['uk'][6] = 'July';
  monat['uk'][7] = 'August';
  monat['uk'][8] = 'September';
  monat['uk'][9] = 'October';
  monat['uk'][10] = 'November';
  monat['uk'][11] = 'December';
  
  if (monat[sprache]){
    if (monat[sprache][index]){
      return monat[sprache][index];
    }
  }
  else{
    if (monat['de'][index]){
      return monat['de'][index];
    }
  }
  return undefined;
}

// -------------------------------------------
// DateProperties.monatNameKurz(sprache)
// -------------------------------------------
//
// Beschreibung:
// -------------
// Methode liefert Monatname in angeforderter Sprache zurück
// Standard = de
//
// Beispiel:
// ---------
// DateProperties.monatName(3, 'uk');

DateProperties.monatNameKurz = function(index, sprache) {
  var monat = {};
  index = parseFloat(index);
  
  monat['de'] = [];
  monat['uk'] = [];
  
  monat['de'][0] = 'Jan';
  monat['de'][1] = 'Feb';
  monat['de'][2] = 'März';
  monat['de'][3] = 'April';
  monat['de'][4] = 'Mai';
  monat['de'][5] = 'Juni';
  monat['de'][6] = 'Juli';
  monat['de'][7] = 'Aug';
  monat['de'][8] = 'Sep';
  monat['de'][9] = 'Okt';
  monat['de'][10] = 'Nov';
  monat['de'][11] = 'Dez';
  
  monat['uk'][0] = 'Jan';
  monat['uk'][1] = 'Feb';
  monat['uk'][2] = 'March';
  monat['uk'][3] = 'April';
  monat['uk'][4] = 'May';
  monat['uk'][5] = 'June';
  monat['uk'][6] = 'July';
  monat['uk'][7] = 'Aug';
  monat['uk'][8] = 'Sep';
  monat['uk'][9] = 'Oct';
  monat['uk'][10] = 'Nov';
  monat['uk'][11] = 'Dec';
  
  if (monat[sprache]){
    if (monat[sprache][index]){
      return monat[sprache][index];
    }
  }
  else{
    if (monat['de'][index]){
      return monat['de'][index];
    }
  }
  return undefined;
}


// -------------------------------------------
// DateProperties.wochenTageName(sprache)
// -------------------------------------------
//
// Beschreibung:
// -------------
// Methode liefert Wochtagname in angeforderter Sprache zurück
// Standard = de
//
// Beispiel:
// ---------
// DateProperties.wochenTageName(3, 'uk');

DateProperties.wochenTageName = function(index, sprache) {
  var wochenTage = {};
  wochenTage['de'] = [];
  wochenTage['uk'] = [];
  
  wochenTage['de'][0] = 'Sonntag';
  wochenTage['de'][1] = 'Montag';
  wochenTage['de'][2] = 'Dienstag';
  wochenTage['de'][3] = 'Mittwoch';
  wochenTage['de'][4] = 'Donnerstag';
  wochenTage['de'][5] = 'Freitag';
  wochenTage['de'][6] = 'Samstag';
  
  wochenTage['uk'][0] = 'Sunday';
  wochenTage['uk'][1] = 'Monday';
  wochenTage['uk'][2] = 'Tuesday';
  wochenTage['uk'][3] = 'Wednesday';
  wochenTage['uk'][4] = 'Thursday';
  wochenTage['uk'][5] = 'Friday';
  wochenTage['uk'][6] = 'Saturday';
  
  if (wochenTage[sprache]){
    if (wochenTage[sprache][index]){
      return wochenTage[sprache][index];
    }
  }
  else{
    if (wochenTage['de'][index]){
      return wochenTage['de'][index];
    }
  }
  return undefined;
}

// -------------------------------------------
// DateProperties.wochenTageNameKurz(sprache)
// -------------------------------------------
//
// Beschreibung:
// -------------
// Methode liefert Wochtagname-Kurzform in angeforderter Sprache zurück
// Standard = de
//
// Beispiel:
// ---------
// DateProperties.wochenTageNameKurz(3, 'uk');

DateProperties.wochenTageNameKurz = function(index, sprache) {
  var wochenTage = {};
  wochenTage['de'] = [];
  wochenTage['uk'] = [];
  
  wochenTage['de'][0] = 'So';
  wochenTage['de'][1] = 'Mo';
  wochenTage['de'][2] = 'Di';
  wochenTage['de'][3] = 'Mi';
  wochenTage['de'][4] = 'Do';
  wochenTage['de'][5] = 'Fr';
  wochenTage['de'][6] = 'Sa';
  
  wochenTage['uk'][0] = 'Su';
  wochenTage['uk'][1] = 'Mo';
  wochenTage['uk'][2] = 'Tu';
  wochenTage['uk'][3] = 'We';
  wochenTage['uk'][4] = 'Th';
  wochenTage['uk'][5] = 'Fr';
  wochenTage['uk'][6] = 'Sa';
  
  if (wochenTage[sprache]){
    if (wochenTage[sprache][index]){
      return wochenTage[sprache][index];
    }
  }
  else{
    if (wochenTage['de'][index]){
      return wochenTage['de'][index];
    }
  }
  return undefined;
}

// -------------------------------------------
// DateProperties.tagTypName(index, sprache)
// -------------------------------------------
//
// Beschreibung:
// -------------
// Methode liefert Wochtagname in angeforderter Sprache zurück
// Standard = de
//
// Beispiel:
// ---------
// DateProperties.tagTypName(3, 'uk');

DateProperties.tagTypName = function(index, sprache) {
  var tagesTyp = {};
  tagesTyp['de'] = [];
  tagesTyp['uk'] = [];
  
  tagesTyp['de'][0] = 'Wochenarbeitstag';
  tagesTyp['de'][1] = 'Wochenende[Samstag]';
  tagesTyp['de'][2] = 'Wochenende[Sonntag]';
  
  tagesTyp['uk'][0] = 'workingday';
  tagesTyp['uk'][1] = 'weekend[Saturday]';
  tagesTyp['uk'][2] = 'weekend[Sunday]';
  
  if (tagesTyp[sprache]){
    if (tagesTyp[sprache][index]){
      return tagesTyp[sprache][index];
    }
  }
  else{
    if (tagesTyp['de'][index]){
      return tagesTyp['de'][index];
    }
  }
  return undefined;
}

// -------------------------------------------
// DateProperties.checkDateSchaltjahr(jahr)
// -------------------------------------------
//
// Beschreibung:
// -------------
// Die Methode prüft ob Jahr = Schaltjahr
//
// Beispiel:
// ---------
// DateProperties.checkDateSchaltjahr(2004)

DateProperties.checkDateSchaltjahr = function(jahr) {
  if (!Calendartools.checkNumber(jahr)){
    return false;
  }
  n = Calendartools.checkNumber(jahr);
  if (!((jahr % 4 == 0) && (jahr % 100 != 0))||(jahr % 400 == 0)){
    return false;
  }
  return true;
}


// -------------------------------------------
// DateProperties.checkDate(date)
// -------------------------------------------
//
// Beschreibung:
// -------------
//   ...
//
// Beispiel:
// ---------
// DateProperties.checkDate(date);
//

DateProperties.checkDate = function(date) { 
  if (date instanceof Date) {
    return date;
  } else if (date.length == 10) {
    return new Date(date.substring(date.length-4,date.length),parseFloat(date.substring(date.length-7,date.length-5))-1,date.substring(0,2));
  }
  return new Date();
}


// -------------------------------------------
// DateProperties.createDateProperties()
// -------------------------------------------
//
// Beschreibung:
// -------------
//   ...
//
// Beispiel:
// ---------
// DateProperties.createDateProperties({'bundesland':number},{'sprache':'str'});
//

DateProperties.createDateProperties = function() {  
  // defaultArguments
  var defArg = {};
  defArg['datum'] = new Date();
  defArg['sprache'] = 'de';
  // givenArguments
  defArg = Calendartools.getArgumentsAssArray(defArg, arguments);
  return new DateProperties(defArg['datum'], defArg['sprache']);
}

// ------------------------------------------------------------
// toString()
// ------------------------------------------------------------

DateProperties.prototype.toString = function() {
  // zunaechst an Methode der Basisklasse weiterleiten
  //return Object.prototype.toString.apply(this);
  var str = new String();
  str += '<b>DateProperties</b><br>\n\n';
  str += 'datum = ' + this.datum() +'<br>\n\n';
  str += '\tkw = ' + this.kw() +'<br>\n';
  str += 'sprache = ' + this.sprache() +'<br>\n\n';
  str += 'name = ' + this.name() +'<br>\n\n';
  str += 'typ = ' + this.typ() +'<br>\n\n';
  str += 'feierTag = <br>' + this.feierTag() +'<br>\n\n';
  return str;
}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////

// ============================================================
// Klasse Feiertag
// ============================================================

// ------------------------------------------------------------
// Konstruktor
// ------------------------------------------------------------

// ---------------------------------------
// Feiertag(datum)
// ---------------------------------------
//
// Beschreibung:
// -------------
// Konstruiert ein FeierTagObjekt mit optionalen Eigenschaften
//
// Beispiel:
// ---------
// 

function Feiertag(datum, sprache) {  
  // Attribute
  this._datum = undefined;
  this._sprache = undefined;
  this._nameKey = undefined;
  this._statusKey = undefined;
  this._typKey = undefined;
  this._name = undefined;
  this._status = undefined;
  this._typ = undefined;
  this._listBundeslandKey = [];
  this._listBundesland = {};
  
  // Initialisierungen
  this.datum(datum);
  this.sprache(sprache);
  
  if (this._istTagFeiertag(this.datum()) != undefined){
    this.nameKey(this._getNameKey(this.datum()));
    this.statusKey(this._getStatusKey(this.datum()));
    this.typKey(this._getTypKey(this.datum()));  
    this.listBundeslandKey(this._getBundeslandKey(this.datum()));
    this.name(this._getName(this.nameKey()));
    this.status(this._getStatus(this.statusKey()));
    this.typ(this._getTyp(this.typKey()));
    this.listBundesland(this._getBundesland(this.listBundeslandKey()));
  }
}

// ------------------------------------------------------------
// Zugriffsfunktionen
// ------------------------------------------------------------

// -----------
// datum(obj)
// -----------
//
// Beschreibung:
// -------------
//

Feiertag.prototype.datum = function(obj) {
  if (arguments.length) {
    if (! obj instanceof Date) {
      focus();
      throw new Error("ArgumentError:noObjectFromClassDate!");
    }
    this._datum = obj;
  }
  return this._datum;
}

// -----------
// sprache(str)
// -----------
//
// Beschreibung:
// -------------
//

Feiertag.prototype.sprache = function(str) {
  if (arguments.length) {
    if (typeof str != "string") {
      focus();
      throw new Error("ArgumentError:noString!");
    }
    this._sprache = str;
  }
  return this._sprache;
}

// -----------
// nameKey(str)
// -----------
//
// Beschreibung:
// -------------
//

Feiertag.prototype.nameKey = function(n) {
  if (arguments.length) {
    if (!Calendartools.checkNumber(n)) {
      focus();
      throw new Error("ArgumentError:noNumber!");
    }
    this._nameKey = n;
  }
  return this._nameKey;
}

// -----------
// statusKey(str)
// -----------
//
// Beschreibung:
// -------------
//

Feiertag.prototype.statusKey = function(n) {
  if (arguments.length) {
    if (!Calendartools.checkNumber(n)) {
      focus();
      throw new Error("ArgumentError:noNumber!");
    }
    this._statusKey = n;
  }
  return this._statusKey;
}

// -----------
// typKey(str)
// -----------
//
// Beschreibung:
// -------------
//

Feiertag.prototype.typKey = function(n) {
  if (arguments.length) {
    if (!Calendartools.checkNumber(n)) {
      focus();
      throw new Error("ArgumentError:noNumber!");
    }
    this._typKey = n;
  }
  return this._typKey;
}

// --------------
// listBundeslandKey(arr)
// --------------
//
// Beschreibung:
// -------------
//

Feiertag.prototype.listBundeslandKey = function(arr) {
  if (arguments.length) {
    if (! arr instanceof Array) {
      focus();
      throw new Error("ArgumentError:noObjectFromClassArray!");
    }
    this._listBundeslandKey = arr;
  }
  return this._listBundeslandKey;
}

// -----------
// name(str)
// -----------
//
// Beschreibung:
// -------------
//

Feiertag.prototype.name = function(str) {
  if (arguments.length) {
    if (typeof str != "string") {
      focus();
      throw new Error("ArgumentError:noString!");
    }
    this._name = str;
  }
  return this._name;
}

// -----------
// name(str)
// -----------
//
// Beschreibung:
// -------------
//

Feiertag.prototype.status = function(str) {
  if (arguments.length) {
    if (typeof str != "string") {
      focus();
      throw new Error("ArgumentError:noString!");
    }
    this._status = str;
  }
  return this._status;
}

// -----------
// typ(str)
// -----------
//
// Beschreibung:
// -------------
//

Feiertag.prototype.typ = function(str) {
  if (arguments.length) {
    if (typeof str != "string") {
      focus();
      throw new Error("ArgumentError:noString!");
    }
    this._typ = str;
  }
  return this._typ;
}

// --------------
// listBundesland(arr)
// --------------
//
// Beschreibung:
// -------------
//

Feiertag.prototype.listBundesland = function(arr) {
  if (arguments.length) {
    if (! arr instanceof Array) {
      focus();
      throw new Error("ArgumentError:noObjectFromClassArray!");
    }
    this._listBundesland = arr;
  }
  return this._listBundesland;
}

// ------------------------------------------------------------
// Private Instanzmethoden
// ------------------------------------------------------------

// -------------------------------------------
// _istTagFeiertag()
// -------------------------------------------
//
// Beschreibung:
// -------------
// Methode ermittelt Feiertagsnamen
//
// Beispiel:
// ---------
// _istTagFeiertag(datumObj);
//

Feiertag.prototype._istTagFeiertag = function(datumObj) {
  var index = DateProperties.formatDatum(datumObj);
  if (this._createFeiertage()[index]){
    return true;
  }
  return undefined;
}


// -------------------------------------------
// _getNameKey()
// -------------------------------------------
//
// Beschreibung:
// -------------
// Methode ermittelt Feiertagsnamen
//
// Beispiel:
// ---------
// _getNameKey(datumObj);
//

Feiertag.prototype._getNameKey = function(datumObj) {
  var index = DateProperties.formatDatum(datumObj);
  if (this._createFeiertage()[index]){
    return this._createFeiertage()[index]['name'];
  }
  return undefined;
}

// -------------------------------------------
// _getStatusKey()
// -------------------------------------------
//
// Beschreibung:
// -------------
// Methode ermittelt Feiertagsnamen
//
// Beispiel:
// ---------
// _getStatusKey(datumObj);
//

Feiertag.prototype._getStatusKey = function(datumObj) {
  var index = DateProperties.formatDatum(datumObj);
  if (this._createFeiertage()[index]){
    return this._createFeiertage()[index]['status'];
  }
  return undefined;
}

// -------------------------------------------
// _getTypKey()
// -------------------------------------------
//
// Beschreibung:
// -------------
// Methode ermittelt Feiertagsnamen
//
// Beispiel:
// ---------
// _getTypKey(datumObj);
//

Feiertag.prototype._getTypKey = function(datumObj) {
  var index = DateProperties.formatDatum(datumObj);
  if (this._createFeiertage()[index]){
    return this._createFeiertage()[index]['typ'];
  }
  return undefined;
}

// -------------------------------------------
// _getBundeslandKey()
// -------------------------------------------
//
// Beschreibung:
// -------------
// Methode ermittelt BundeslandSchlüssel
//
// Beispiel:
// ---------
// _getBundeslandKey(datumObj);
//

Feiertag.prototype._getBundeslandKey = function(datumObj) {
  var index = DateProperties.formatDatum(datumObj);
  if (this._createFeiertage()[index]){
    return this._createFeiertage()[index]['bundesland'];
  }
  return undefined;
}

// -------------------------------------------
// _getName()
// -------------------------------------------
//
// Beschreibung:
// -------------
// Methode ermittelt Feiertagsnamen
//
// Beispiel:
// ---------
// _getName(datumObj);
//

Feiertag.prototype._getName = function(n) {
  return this._getNameWerte(n);
}

// -------------------------------------------
// _getStatus()
// -------------------------------------------
//
// Beschreibung:
// -------------
// Methode ermittelt Feiertagsnamen
//
// Beispiel:
// ---------
// _getStatus(datumObj);
//

Feiertag.prototype._getStatus = function(n) {
  return this._getStatusWerte(n);
}

// -------------------------------------------
// _getTyp()
// -------------------------------------------
//
// Beschreibung:
// -------------
// Methode ermittelt Feiertagsnamen
//
// Beispiel:
// ---------
// _getStatus(datumObj);
//

Feiertag.prototype._getTyp = function(n) {
  return this._getTypWerte(n);
}

// -------------------------------------------
// _getBundesland()
// -------------------------------------------
//
// Beschreibung:
// -------------
// Methode ermittelt Feiertagsnamen
//
// Beispiel:
// ---------
// _getStatus(datumObj);
//

Feiertag.prototype._getBundesland = function() {
  var myarr = {};
  for (var i=0; i<this.listBundeslandKey().length; i++){
    myarr[this.listBundeslandKey()[i].toString()] = Calendartools.gibBundesland(this.listBundeslandKey()[i], this.sprache());
  }
  return myarr;
}

// -------------------------------------------
// _createOsterSonntag()
// -------------------------------------------
//
// Beschreibung:
// -------------
// Methode  erstell Datum Ostersonntag
//
// Beispiel:
// ---------
// _checkListTagObEintrag(datumObj);
//

Feiertag.prototype._createOsterSonntag = function(datumObj) {
  var jahr = datumObj.getFullYear();
  var gz = (jahr % 19) + 1;
  var jhd = Calendartools.divAbrunden(jahr, 100) + 1;
  var ksj = Calendartools.divAbrunden((3 * jhd), 4) - 12;
  var korr = Calendartools.divAbrunden((8 * jhd + 5), 25) - 5;
  var so = Calendartools.divAbrunden((5 * jahr), 4) - ksj - 10;
  var epakte = (11 * gz + 20 + korr - ksj) % 30;
  if (((epakte == 25) && (gz > 11)) || (epakte == 24)) epakte++;
  var m = 44 - epakte;
  if (m < 21) m += 30;
  m = m + 7 - (so + m) % 7;
  if (DateProperties.checkDateSchaltjahr(jahr)) m++;
  m = parseFloat(m + 59);
  var jahresanfang =  new Date(jahr,00,01,3,00,00);
  var osterSonntag = new Date(new Date().setTime(parseFloat(jahresanfang.getTime() + ((m-1) * 24 * 60 * 60 * 1000))));
  return osterSonntag;
  
}

// -------------------------------------------
// _createfourthAdvent()
// -------------------------------------------
//
// Beschreibung:
// -------------
// Methode  erstell Datum 4. Advent
//
// Beispiel:
// ---------
// _createfourthAdvent(datumObj);
//

Feiertag.prototype._createfourthAdvent = function(datumObj) {
  var jahr = datumObj.getFullYear();
  var startDatum  = new Date(jahr, 11, 25, 04, 00, 00);
  var wTag  = startDatum.getDay();
  var temp  = startDatum.getTime();
  var advent4 = new Date(startDatum.setTime(temp - ((wTag == 0) ? 7 : wTag) * 86400000));
  return advent4;
  
}

// -------------------------------------------
// _createFeiertage()
// -------------------------------------------
//
// Beschreibung:
// -------------
//
//
// Beispiel:
// ---------
// _createFeiertage();
//

Feiertag.prototype._createFeiertage = function() {
  if (Feiertag._feierTagSpeicher[this.datum().getFullYear()] == undefined){
    Feiertag._feierTagSpeicher[this.datum().getFullYear()] = this._createFeiertageList();
  }
  return Feiertag._feierTagSpeicher[this.datum().getFullYear()];
}

// -------------------------------------------
// _createFeiertageList()
// -------------------------------------------
//
// Beschreibung:
// -------------
// Methode  erstell List der Feiertage im Jahr
//
// Beispiel:
// ---------
// _createFeiertageList();
//

Feiertag.prototype._createFeiertageList = function() {
  var jahr = this.datum().getFullYear();
  var arr = [];
  
  var index;
  
  var osterSonntag = this._createOsterSonntag(this.datum());
  var advent4 = this._createfourthAdvent(this.datum());
  
  //Neujahr
  index = parseFloat(jahr + '0101');
  arr[index] = {};
  arr[index]['name'] = 0;
  arr[index]['status'] = 1;
  arr[index]['typ'] = 1;
  arr[index]['bundesland'] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15];
  
  //Heilige Drei Könige
  index = parseFloat(jahr + '0106');
  arr[index] = {};
  arr[index]['name'] = 1;
  arr[index]['status'] = 1;
  arr[index]['typ'] = 1;
  arr[index]['bundesland'] = [0, 1, 13];
  
  //Rosenmontag
  index = parseFloat(DateProperties.formatDatum(DateProperties.addiereAnzahlTageZuDatum(osterSonntag,-48)));
  arr[index] = {};
  arr[index]['name'] = 24;
  arr[index]['status'] = 0;
  arr[index]['typ'] = 2;
  arr[index]['bundesland'] = [6, 9, 10];
  
  //Fastnachtdienstag
  index = parseFloat(DateProperties.formatDatum(DateProperties.addiereAnzahlTageZuDatum(osterSonntag,-47)));
  arr[index] = {};
  arr[index]['name'] = 25;
  arr[index]['status'] = 0;
  arr[index]['typ'] = 2;
  arr[index]['bundesland'] = [6, 9, 10];
  
  //Aschermittwoch
  index = parseFloat(DateProperties.formatDatum(DateProperties.addiereAnzahlTageZuDatum(osterSonntag,-46)));
  arr[index] = {};
  arr[index]['name'] = 2;
  arr[index]['status'] = 0;
  arr[index]['typ'] = 1;
  arr[index]['bundesland'] = [6, 9, 10];
  
  //Karfreitag
  index = parseFloat(DateProperties.formatDatum(DateProperties.addiereAnzahlTageZuDatum(osterSonntag,-2)));
  arr[index] = {};
  arr[index]['name'] = 3;
  arr[index]['status'] = 1;
  arr[index]['typ'] = 1;
  arr[index]['bundesland'] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15];
  
  //Ostersamstag
  index = parseFloat(DateProperties.formatDatum(DateProperties.addiereAnzahlTageZuDatum(osterSonntag,-1)));
  arr[index] = {};
  arr[index]['name'] = 28;
  arr[index]['status'] = 0;
  arr[index]['typ'] = 1;
  arr[index]['bundesland'] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15];
  
  //Ostersonntag
  index = parseFloat(DateProperties.formatDatum(osterSonntag));
  arr[index] = {};
  arr[index]['name'] = 4;
  arr[index]['status'] = 1;
  arr[index]['typ'] = 1;
  arr[index]['bundesland'] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15];
  
  //Ostermontag
  index = parseFloat(DateProperties.formatDatum(DateProperties.addiereAnzahlTageZuDatum(osterSonntag,1)));
  arr[index] = {};
  arr[index]['name'] = 5;
  arr[index]['status'] = 1;
  arr[index]['typ'] = 1;
  arr[index]['bundesland'] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15];
  
  //Tag der Arbeit
  index = parseFloat(jahr + '0501');
  arr[index] = {};
  arr[index]['name'] = 6;
  arr[index]['status'] = 1;
  arr[index]['typ'] = 0;
  arr[index]['bundesland'] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15];
  
  //Christi Himmelfahrt
  index = parseFloat(DateProperties.formatDatum(DateProperties.addiereAnzahlTageZuDatum(osterSonntag,39)));
  arr[index] = {};
  arr[index]['name'] = 7;
  arr[index]['status'] = 1;
  arr[index]['typ'] = 1;
  arr[index]['bundesland'] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15];
  
  //Pfingstsonntag
  index = parseFloat(DateProperties.formatDatum(DateProperties.addiereAnzahlTageZuDatum(osterSonntag,49)));
  arr[index] = {};
  arr[index]['name'] = 8;
  arr[index]['status'] = 1;
  arr[index]['typ'] = 1;
  arr[index]['bundesland'] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15];
  
  //Pfingstmontag
  index = parseFloat(DateProperties.formatDatum(DateProperties.addiereAnzahlTageZuDatum(osterSonntag,50)));
  arr[index] = {};
  arr[index]['name'] = 9;
  arr[index]['status'] = 1;
  arr[index]['typ'] = 1;
  arr[index]['bundesland'] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15];
  
  //Fronleichnam
  index = parseFloat(DateProperties.formatDatum(DateProperties.addiereAnzahlTageZuDatum(osterSonntag,60)));
  arr[index] = {};
  arr[index]['name'] = 10;
  arr[index]['status'] = 1;
  arr[index]['typ'] = 1;
  arr[index]['bundesland'] = [0, 1, 6, 9, 10, 11, 12, 15];
  
  //Maria Himmelfahrt
  index = parseFloat(jahr + '0815');
  arr[index] = {};
  arr[index]['name'] = 11;
  arr[index]['status'] = 1;
  arr[index]['typ'] = 1;
  arr[index]['bundesland'] = [1, 11];
  
  //Tag der dt. Einheit
  index = parseFloat(jahr + '1003');
  arr[index] = {};
  arr[index]['name'] = 12;
  arr[index]['status'] = 1;
  arr[index]['typ'] = 0;
  arr[index]['bundesland'] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15];
  
  //Reformationstag
  index = parseFloat(jahr + '1031');
  arr[index] = {};
  arr[index]['name'] = 13;
  arr[index]['status'] = 1;
  arr[index]['typ'] = 1;
  arr[index]['bundesland'] = [3, 7, 12, 13, 15];
  
  //Allerheiligen
  index = parseFloat(jahr + '1101');
  arr[index] = {};
  arr[index]['name'] = 14;
  arr[index]['status'] = 1;
  arr[index]['typ'] = 1;
  arr[index]['bundesland'] = [0, 1, 9, 10, 11]; 
  
  //Volkstrauertag
  index = parseFloat(DateProperties.formatDatum(DateProperties.addiereAnzahlTageZuDatum(advent4,-35)));
  arr[index] = {};
  arr[index]['name'] = 27;
  arr[index]['status'] = 0;
  arr[index]['typ'] = 0;
  arr[index]['bundesland'] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15];
  
  //Buß- und Bettag
  index = parseFloat(DateProperties.formatDatum(DateProperties.addiereAnzahlTageZuDatum(advent4,-32)));
  arr[index] = {};
  arr[index]['name'] = 15;
  arr[index]['status'] = 1;
  arr[index]['typ'] = 1;
  arr[index]['bundesland'] = [12];
  
  //Totensonntag
  index = parseFloat(DateProperties.formatDatum(DateProperties.addiereAnzahlTageZuDatum(advent4,-28)));
  arr[index] = {};
  arr[index]['name'] = 26;
  arr[index]['status'] = 0;
  arr[index]['typ'] = 1;
  arr[index]['bundesland'] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15];
  
  //1. Advent
  index = parseFloat(DateProperties.formatDatum(DateProperties.addiereAnzahlTageZuDatum(advent4,-21)));
  arr[index] = {};
  arr[index]['name'] = 16;
  arr[index]['status'] = 1;
  arr[index]['typ'] = 1;
  arr[index]['bundesland'] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]; 
  
  //2. Advent
  index = parseFloat(DateProperties.formatDatum(DateProperties.addiereAnzahlTageZuDatum(advent4,-14)));
  arr[index] = {};
  arr[index]['name'] = 17;
  arr[index]['status'] = 1;
  arr[index]['typ'] = 1;
  arr[index]['bundesland'] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15];
  
  //3. Advent
  index = parseFloat(DateProperties.formatDatum(DateProperties.addiereAnzahlTageZuDatum(advent4,-7)));
  arr[index] = {};
  arr[index]['name'] = 18;
  arr[index]['status'] = 1;
  arr[index]['typ'] = 1;
  arr[index]['bundesland'] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15];
  
  //4. Advent
  index = parseFloat(DateProperties.formatDatum(advent4));
  arr[index] = {};
  arr[index]['name'] = 19;
  arr[index]['status'] = 1;
  arr[index]['typ'] = 1;
  arr[index]['bundesland'] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15];
  
  //HL. Abend
  index = parseFloat(jahr + '1224');
  arr[index] = {};
  arr[index]['name'] = 20;
  arr[index]['status'] = 2;
  arr[index]['typ'] = 1;
  arr[index]['bundesland'] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15];
  
  //1. Weihnachtstag
  index = parseFloat(jahr + '1225');
  arr[index] = {};
  arr[index]['name'] = 21;
  arr[index]['status'] = 1;
  arr[index]['typ'] = 1;
  arr[index]['bundesland'] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15];
  
  //2. Weihnachtstag
  index = parseFloat(jahr + '1226');
  arr[index] = {};
  arr[index]['name'] = 22;
  arr[index]['status'] = 1;
  arr[index]['typ'] = 1;
  arr[index]['bundesland'] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15];
  
  //Silvester
  index = parseFloat(jahr + '1231');
  arr[index] = {};
  arr[index]['name'] = 23;
  arr[index]['status'] = 2;
  arr[index]['typ'] = 1;
  arr[index]['bundesland'] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15];
  
  return arr;     
}

// -------------------------------------------
// _getNameWerte()
// -------------------------------------------
//
// Beschreibung:
// -------------
// Methode gibt den Namen des Feiertages zurück
//
// Beispiel:
// ---------
// _getNameWerte(index);
//

Feiertag.prototype._getNameWerte = function(n) {
  
  var FeiertagName = {};
  
  FeiertagName['de'] = [];
  FeiertagName['de'][0] = 'Neujahr';
  FeiertagName['de'][1] = 'Heilige Drei Könige';
  FeiertagName['de'][2] = 'Aschermittwoch';
  FeiertagName['de'][3] = 'Karfreitag';
  FeiertagName['de'][4] = 'Ostersonntag';
  FeiertagName['de'][5] = 'Ostermontag';
  FeiertagName['de'][6] = 'Tag der Arbeit';
  FeiertagName['de'][7] = 'Christi Himmelfahrt';
  FeiertagName['de'][8] = 'Pfingstsonntag';
  FeiertagName['de'][9] = 'Pfingstmontag';
  FeiertagName['de'][10] = 'Fronleichnam';
  FeiertagName['de'][11] = 'Maria Himmelfahrt';
  FeiertagName['de'][12] = 'Tag der dt. Einheit';
  FeiertagName['de'][13] = 'Reformationstag';
  FeiertagName['de'][14] = 'Allerheiligen';
  FeiertagName['de'][15] = 'Buß- und Bettag';
  FeiertagName['de'][16] = '1. Advent';
  FeiertagName['de'][17] = '2. Advent';
  FeiertagName['de'][18] = '3. Advent';
  FeiertagName['de'][19] = '4. Advent';
  FeiertagName['de'][20] = 'Heiligabend';
  FeiertagName['de'][21] = '1. Weihnachtstag';
  FeiertagName['de'][22] = '2. Weihnachtstag';
  FeiertagName['de'][23] = 'Silvester';
  FeiertagName['de'][24] = 'Rosenmontag';
  FeiertagName['de'][25] = 'Fastnachtdienstag';
  FeiertagName['de'][26] = 'Totensonntag';
  FeiertagName['de'][27] = 'Volkstrauertag';
  FeiertagName['de'][28] = 'Karsamstag';
  
  if (FeiertagName[this.sprache()]){
    if (FeiertagName[this.sprache()][n]){
      return FeiertagName[this.sprache()][n];
    }
  }
  else{
    if (FeiertagName['de'][n]){
      return FeiertagName['de'][n];
    }
  }
  
  return undefined;  
}

// -------------------------------------------
// _getStatusWerte()
// -------------------------------------------
//
// Beschreibung:
// -------------
// Methode gibt den Namen des FeiertagStatus zurück
//
// Beispiel:
// ---------
// _getStatusWerte(index);
//

Feiertag.prototype._getStatusWerte = function(n) {
  
  var FeiertagStatus = {};
  
  FeiertagStatus['de'] = [];
  FeiertagStatus['de'][0] = 'nicht arbeitsfrei';
  FeiertagStatus['de'][1] = 'arbeitsfrei';
  FeiertagStatus['de'][2] = '1/2 Tag arbeitsfrei';
  
  if (FeiertagStatus[this.sprache()]){
    if (FeiertagStatus[this.sprache()][n]){
      return FeiertagStatus[this.sprache()][n];
    }
  }
  else{
    if (FeiertagStatus['de'][n]){
      return FeiertagStatus['de'][n];
    }
  }
  
  return undefined;  
}

// -------------------------------------------
// _getTypWerte()
// -------------------------------------------
//
// Beschreibung:
// -------------
// Methode gibt den Namen des FeiertagStatus zurück
//
// Beispiel:
// ---------
// _getTypWerte(index);
//

Feiertag.prototype._getTypWerte = function(n) {
  
  var FeiertagTyp = {};
  
  FeiertagTyp['de'] = [];
  FeiertagTyp['de'][0] = 'staatlicher Feiertag';
  FeiertagTyp['de'][1] = 'kirchlicher Feiertag';
  FeiertagTyp['de'][2] = 'regionales Brauchtum';
  
  if (FeiertagTyp[this.sprache()]){
    if (FeiertagTyp[this.sprache()][n]){
      return FeiertagTyp[this.sprache()][n];
    }
  }
  else{
    if (FeiertagTyp['de'][n]){
      return FeiertagTyp['de'][n];
    }
  }
  
  return undefined;  
}

// ------------------------------------------------------------
// Öffentliche Instanzmethoden
// ------------------------------------------------------------

// ------------------------------------------------------------
// Öffentliche Klasseneigenschaften
// ------------------------------------------------------------

// ------------------------------------------------------------
// Private Klasseneigenschaften
// ------------------------------------------------------------

Feiertag._feierTagSpeicher = [];

// ------------------------------------------------------------
// Öffentliche Klassenmethoden
// ------------------------------------------------------------

// -------------------------------------------
// Feiertag.createFeiertag(datum)
// -------------------------------------------
//
// Beschreibung:
// -------------
//   ...
//
// Beispiel:
// ---------
// Feiertag.createFeiertag({'datum':new Date()});
//

Feiertag.createFeiertag = function() {  
  // defaultArguments
  var defArg = {};
  defArg['datum'] = new Date();
  defArg['sprache'] = 'de';
  // givenArguments
  defArg = Calendartools.getArgumentsAssArray(defArg, arguments);
  return new Feiertag(defArg['datum'], defArg['sprache']);
}

// ------------------------------------------------------------
// Private Klassenmethoden
// ------------------------------------------------------------

// ------------------------------------------------------------
// toString()
// ------------------------------------------------------------

Feiertag.prototype.toString = function() {
  // zunaechst an Methode der Basisklasse weiterleiten
  //return Object.prototype.toString.apply(this);
  var str = new String();
  str += '<b>Feiertag</b><br>'
  str += '\tdatum = ' + this.datum() +'<br>\n';
  str += '\tsprache = ' + this.sprache() +'<br>\n';
  str += '\tnameKey = ' + this.nameKey() +'<br>\n';
  str += '\tstatusKey = ' + this.statusKey() +'<br>\n';
  str += '\ttypKey = ' + this.typKey() +'<br>\n';
  str += '\tname = ' + this.name() +'<br>\n';
  str += '\tstatus = ' + this.status() +'<br>\n';
  str += '\ttyp = ' + this.typ() +'<br>\n';
  str += '\tlistBundesland = ' + this.listBundesland() +'<br>\n';
  return str;
}


// ============================================================
// Klasse Calendartools
// ============================================================

// ------------------------------------------------------------
// Konstruktor
// ------------------------------------------------------------

// ---------------------------------------
// Calendartools()
// ---------------------------------------
//
// Beispiel:
// ---------
// new Calendartools()
//
function Calendartools() {
}

// ------------------------------------------------------------
// Zugriffsfunktionen
// ------------------------------------------------------------

// ------------------------------------------------------------
// Öffentliche Instanzmethoden
// ------------------------------------------------------------

// ------------------------------------------------------------
// Private Instanzmethoden
// ------------------------------------------------------------

// ------------------------------------------------------------
// Öffentliche Klasseneigenschaften
// ------------------------------------------------------------

// ------------------------------------------------------------
// Private Klasseneigenschaften
// ------------------------------------------------------------

// ------------------------------------------------------------
// Öffentliche Klassenmethoden
// ------------------------------------------------------------

// -------------------------------------------
// Calendartools.checkNumber()
// -------------------------------------------
//
// Beschreibung:
// -------------
// Methode prüft Argument auf type Number
//
// Beispiel:
// ---------
// Calendartools.checkNumber(n);

Calendartools.checkNumber = function(n){
  if (!arguments.length){
    return false;
  }
  if (n == undefined){
    return false;
  }
  n = n.toString();
  if (n == '0'){
    return n;
  }
  if (!n.length){
    return false;
  }
  n = n.replace(/,/g,'.');
  if (isNaN(n)){
    return false;
  }
  if (!isFinite(n)) {
    return false;
  }
  n = parseFloat(n);
  return n;
}

// -------------------------------------------
// Calendartools.divAbrunden()
// -------------------------------------------
//
// Beschreibung:
// -------------
// Methode führt eine division durch und rundet Ergebnis ab.
//
// Beispiel:
// ---------
// Calendartools.divAbrunden(dividend, divisor);

Calendartools.divAbrunden = function(dividend, divisor){
  return Math.floor (dividend / divisor);
}

// -------------------------------------------
// Calendartools.checkWertInArrayVorhanden(str, arr)
// -------------------------------------------
//
// Beschreibung:
// -------------
// Methode prüft ob ein Wert in einem Array vorhanden ist.
// Argument = wert und jeweiliges Array
//
// Beispiel:
// ---------
// Calendartools.checkWertinArrayVorhanden(str, arr);

Calendartools.checkWertInArrayVorhanden = function(){
  var str = arguments[0];
  var arr = new Array();
  arr = arguments[1];
  for (var i in arr){
    if (arr[i] == str){
      return true;
    } 
  }
  return false;
}


// -------------------------------------------
// Calendartools.getAssArrayFromArgArr(assArr, argArr)
// -------------------------------------------
//
// Beschreibung:
// -------------
// Methode extrahiert aus einem ArgumentArray die AssoziativenArray und überschreibt das mitgelieferte AssoziativeArray,
// welches zurückgegeben wird.
//
// Beispiel:
// ---------
// Calendartools.getArgumentsAssArray(assArr, argArr);

Calendartools.getArgumentsAssArray = function(){
  var assArr = {};
  var argArr = [];
  assArr = arguments[0];
  argArr = arguments[1];
  if (argArr.length){
    var tempAssArr = [];
    for (var i=0; i<argArr.length; i++){
      tempAssArr[i] = {};
      tempAssArr[i] = argArr[i];
      for (var k in tempAssArr[i]){
        assArr[k] = tempAssArr[i][k];
      }
    }
  }  
  return assArr;
}

// -------------------------------------------
// Calendartools.gibBundesland(n)
// -------------------------------------------
//
// Beschreibung:
// -------------
// Methode gibt ein dt. Bundesland zurück
//
// Beispiel:
// ---------
// Calendartools.gibBundesland(n);

Calendartools.gibBundesland = function(n){
  var bundesland = [];
  bundesland[0] = 'Baden-Württemberg';
  bundesland[1] = 'Bayern';
  bundesland[2] = 'Berlin';
  bundesland[3] = 'Brandenburg';
  bundesland[4] = 'Bremen';
  bundesland[5] = 'Hamburg';
  bundesland[6] = 'Hessen';
  bundesland[7] = 'Mecklenburg-Vorpommern';
  bundesland[8] = 'Niedersachsen';
  bundesland[9] = 'Nordrhein-Westfalen';
  bundesland[10] = 'Rheinland-Pfalz';
  bundesland[11] = 'Saarland';
  bundesland[12] = 'Sachsen';
  bundesland[13] = 'Sachsen-Anhalt';
  bundesland[14] = 'Schleswig-Holstein';
  bundesland[15] = 'Thüringen';
  
  if(bundesland[n]){
    return bundesland[n];
  }
  return undefined;
}

// -------------------------------------------
// Calendartools.gibBundeslaender()
// -------------------------------------------
//
// Beschreibung:
// -------------
// Methode gibt eine Liste der dt. Bundesländer zurück
//
// Beispiel:
// ---------
// Calendartools.gibBundeslaender();

Calendartools.gibBundeslaender = function(){
  var bundesland = [];
  bundesland[0] = 'Baden-Württemberg';
  bundesland[1] = 'Bayern';
  bundesland[2] = 'Berlin';
  bundesland[3] = 'Brandenburg';
  bundesland[4] = 'Bremen';
  bundesland[5] = 'Hamburg';
  bundesland[6] = 'Hessen';
  bundesland[7] = 'Mecklenburg-Vorpommern';
  bundesland[8] = 'Niedersachsen';
  bundesland[9] = 'Nordrhein-Westfalen';
  bundesland[10] = 'Rheinland-Pfalz';
  bundesland[11] = 'Saarland';
  bundesland[12] = 'Sachsen';
  bundesland[13] = 'Sachsen-Anhalt';
  bundesland[14] = 'Schleswig-Holstein';
  bundesland[15] = 'Thüringen';
  return bundesland;
}

// ------------------------------------------------------------
// Private Klassenmethoden
// ------------------------------------------------------------

// ------------------------------------------------------------
// toString()
// ------------------------------------------------------------

Calendartools.prototype.toString = function() {
  // zunaechst an Methode der Basisklasse weiterleiten
  return Object.prototype.toString.apply(this);
}