YAHOO.namespace("account.container");

var Account = {
	base: null,
	
	regform: null,
	regerr: null,
	regok: null,
	
	confform: null,
	conferr: null,
	confok: null,
	
	infoform: null,
	infoerr: null,
	
	fieldset: {
		en: {
			login: 'Username',
			email: 'E-mail',
			name: 'Name',
			surname: 'Surname',
			city: 'City',
			address: 'Address', 
			zip: 'Postal code/ZIP'
		},
		nl: {
			login: 'Gebruikersnaam',
			email: 'Email',
			name: 'Voornaam',
			surname: 'Achternaam',
			city: 'Woonplaats',
			address: 'Adres', 
			zip: 'Postcode'
		},
		de: {
			login: 'Benutzername',
			email: 'Emailadresse',
			name: 'Vorname',
			surname: 'Nachname',
			city: 'Wohnort',
			address: 'Adresse', 
			zip: 'Postleitzahl'
		},
		pl: {
			login: 'Nazwa użytkownika',
			email: 'E-mail',
			name: 'Imię',
			surname: 'Nazwisko',
			city: 'Miasto',
			address: 'Adres', 
			zip: 'Kod pocztowy'
		},
		es: {
			login: 'Nombre de Usuario',
			email: 'Correo electrónico',
			name: 'Nombre',
			surname: 'Apellido',
			city: 'Ciudad',
			address: 'Dirección', 
			zip: 'Código Postal'
		}
	},
	
	fieldset2: {
		en: {
			pass: 'Password',
			pass_conf: 'Password confirmation',
			acc_name: 'Name accountholder',
			acc_country: 'Country', 
			acc_number: 'Account number beneficiary',
			acc_bank: 'Name bank',
			acc_city_bank: 'City bank'
		},
		nl: {
			pass: 'Paswoord',
			pass_conf: 'Paswoord bevestiging',
			acc_name: 'Naam houder bankrekening',
			acc_country: 'Land bank', 
			acc_number: 'Bankrekeningnummer',
			acc_bank: 'Naam bank',
			acc_city_bank: 'Plaats bank'
		},
		de: {
			pass: 'Passwort',
			pass_conf: 'Passwortbestätigung',
			acc_name: 'Name des Kontobesitzers',
			acc_country: 'Land Bank', 
			acc_number: 'Kontonummer',
			acc_bank: 'Name Bank',
			acc_city_bank: 'Standort Bank'
		},
		pl: {
			pass: 'Hasło',
			pass_conf: 'Potwierdzenie hasła',
			acc_name: 'Dane posiadacza konta (beneficjenta)',
			acc_country: 'Państwo bank', 
			acc_number: 'Numer konta (beneficjenta)',
			acc_bank: 'Nazwa banku',
			acc_city_bank: 'Miasto, w którym zlokalizowany jest bank'
		},
		es: {
			pass: 'Contraseña',
			pass_conf: 'Confirmación contraseña',
			acc_name: 'Nombre del cuentahabiente (beneficiario)',
			acc_country: 'País del banco', 
			acc_number: 'Número de cuenta del beneficiario',
			acc_bank: 'Nombre del banco',
			acc_city_bank: 'Ciudad del banco'
		}
	},
	
	getFormElements: function (form_name) {
		var tmp = YAHOO.util.Dom.getElementsBy(
			function (obj) {
				if (obj && obj.nodeName && (
					obj.nodeName.toLowerCase() == 'input' ||
					obj.nodeName.toLowerCase() == 'select' ||
					obj.nodeName.toLowerCase() == 'textarea'
				)) {
					return true;
				}
				return false;
			},
			null,
			document.forms[form_name]
		);
		var result = {};
		for (var i in tmp) {
			
			if (!tmp[i].name) {
				continue;
			}
			result[tmp[i].name] = tmp[i];
		}
		
		return result;
	},
	
	doChangeFormState: function (form, state) {
		var self = YAHOO.account.container.handler;
		var inputs = self.getFormElements(form);
		
		for (var i in inputs) {
			inputs[i].disabled = !state;
		}
	},
	
	trim: function(str) {
		str = str.replace(/^[\s]+/, '');
		return str.replace(/[\s]+$/, '');
	},
	
	onRequestFailed: function() {
		alert('Unable to connect to server. Try again in few minutes.');
	},
	
	showError: function(name, msg) {
		
		var self = YAHOO.account.container.handler;
		if (self[name]) {
			self[name].innerHTML = msg;
			self[name].style.display = 'block';
		}
	},
	
	hideError: function(name) {
		var self = YAHOO.account.container.handler;
		if (self[name]) {
			self[name].style.display = 'none';
		}
	},
	
	onRegResponse: function(obj) {
		
		var self = YAHOO.account.container.handler;
		self.doChangeFormState(self.regform, true);
		if (obj.responseText != 'ok') {
			self.showError('regerr', obj.responseText);
		}
		else {
			self.regform.style.display = 'none';
			self.regok.style.display = 'block';
		}
	},
	
	register: function() {
		
		var self = YAHOO.account.container.handler;
		var vars = self.fieldset[self._lang];
		/*
		{
			login: 'Username',
			email: 'E-mail',
			name: 'Name',
			surname: 'Surname',
			city: 'City',
			address: 'Address', 
			zip: 'Postal code/ZIP'
		};
		*/
		
		for (var i in vars) {
			
			if (!self.regform[i]) {
				continue;
			}
			
			self.regform[i].value = self.trim(self.regform[i].value);
			if (self.regform[i].value.length == 0) {
				var errors = {
					en: 'Field \'' + vars[i] + '\' is required',
					nl: '\'' + vars[i] + '\' moet worden ingevuld',
					de: '\'' + vars[i] + '\' muss ausgefüllt werden',
					pl: 'Pole \'' + vars[i] + '\' musi być wypełnione',
					es: '\'' + vars[i] + '\' no puede quedar vacío'
				};
				self.showError('regerr', errors[self._lang]);
				return;
			}
		}
		
		if (self.regform['country'].value == '0') {
			var errors = {
				en: 'Select your country from the list',
				nl: 'Selecteer het juiste land uit de lijst',
				de: 'Wählen Sie das zutreffende Land aus der Liste',
				pl: 'Pole "Państwo" musi być wypełnione',
				es: 'País no puede quedar vacío'
			};
			self.showError('regerr', errors[self._lang]);
			return;
		}
		
		var callback = {
			success: self.onRegResponse,
			failure: self.onRequestFailed
		};
		
		var url = self.base + 'register/new/';
		YAHOO.util.Connect.setForm(self.regform);
		YAHOO.util.Connect.asyncRequest('POST', url, callback);
		self.doChangeFormState(self.regform, false);
	},
	
	onConfResponse: function(obj) {
		
		var self = YAHOO.account.container.handler;
		self.doChangeFormState(self.regform, true);
		
		var ok = obj.responseText.substr(0, 2);
		if (ok != 'ok') {
			self.showError('conferr', obj.responseText);
			return;
		}
		
		if (obj.responseText.substr(0, 3) == 'ok;') {
			var url = obj.responseText.substr(3);
			document.location.href = self.base + url;
		}
	},
	
	confirm: function() {
		
		var self = YAHOO.account.container.handler;
		var vars = self.fieldset2[self._lang];
		/*
		{
			pass: 'Password',
			pass_conf: 'Password confirmation',
			acc_name: 'Name accountholder',
			//acc_city: 'City beneficiary',
			acc_country: 'Country', 
			acc_number: 'Account number beneficiary',
			acc_bank: 'Name bank',
			acc_city_bank: 'City bank'
			//acc_code: 'Swift code/IBAN',
			//acc_bic: 'BIC'
		};
		*/
		
		for (var i in vars) {
			
			if (!self.confform[i]) {
				continue;
			}
			
			if (self.confform[i].nodeName.toLowerCase() != 'select') {
				self.confform[i].value = self.trim(self.confform[i].value);
			}
			
			if (self.confform[i].value.length == 0 || self.confform[i].value == '0') {
				var errors = {
					en: 'Field \'' + vars[i] + '\' is required',
					nl: '\'' + vars[i] + '\' moet worden ingevuld',
					de: '\'' + vars[i] + '\' muss ausgefüllt werden',
					pl: 'Pole \'' + vars[i] + '\' musi być wypełnione',
					es: '\'' + vars[i] + '\' no puede quedar vacío'
				};
				self.showError('conferr', errors[self._lang]);
				return;
			}
		}
		
		if (self.confform['pass'].value != self.confform['pass_conf'].value) {
			var errors = {
				en: 'Password and password confirmation should be the same',
				nl: 'Paswoord en paswoord bevestiging moeten overeenkomen',
				de: 'Passwort und Passwortbestätigung müssen übereinstimmen',
				pl: 'Twoje hasło i potwierdzenie hasła powinny być takie same',
				es: 'Su contraseña y la confirmación de la misma deben ser iguales'
			};
			self.showError('conferr', errors[self._lang]);
			return;
		}
		
		self.hideError('conferr');
		
		var callback = {
			success: self.onConfResponse,
			failure: self.onRequestFailed
		};
		
		var url = self.base + 'account/update/payment/';
		YAHOO.util.Connect.setForm(self.confform);
		YAHOO.util.Connect.asyncRequest('POST', url, callback);
		self.doChangeFormState(self.confform, false);
	},
	
	onInfoResponse: function(obj) {
		
		var self = YAHOO.account.container.handler;
		self.doChangeFormState(self.infoform, true);
		if (obj.responseText != 'ok') {
			self.showError('infoerr', obj.responseText);
		}
		else {
			self.showError('infoerr', 'Account info successfully updated');
		}
	},
	
	updateInfo: function() {
		
		var self = YAHOO.account.container.handler;
		var vars = {
			company: 'Company / Private account',
			email: 'E-mail',
			name: 'Name',
			surname: 'Surname',
			city: 'City',
			address: 'Address', 
			zip: 'Postal code/ZIP'
		};
		
		for (var i in vars) {
			
			if (!self.infoform[i]) {
				continue;
			}
			
			if (self.infoform[i].nodeName.toLowerCase() != 'select') {
				self.infoform[i].value = self.trim(self.infoform[i].value);
			}
			
			if (self.infoform[i].value.length == 0 || self.infoform[i].value == '0') {
				var errors = {
					en: 'Field \'' + vars[i] + '\' is required',
					nl: '\'' + vars[i] + '\' moet worden ingevuld',
					de: '\'' + vars[i] + '\' muss ausgefüllt werden',
					pl: 'Pole \'' + vars[i] + '\' musi być wypełnione',
					es: '\'' + vars[i] + '\' no puede quedar vacío'
				};
				self.showError('infoerr', errors[self._lang]);
				return;
			}
		}
		
		self.hideError('infoerr');
		
		var callback = {
			success: self.onInfoResponse,
			failure: self.onRequestFailed
		};
		
		var url = self.base + 'account/update/profile/';
		YAHOO.util.Connect.setForm(self.infoform);
		YAHOO.util.Connect.asyncRequest('POST', url, callback);
		self.doChangeFormState(self.infoform, false);
	},
	
	onEmailResponse: function(obj) {
		
		var self = YAHOO.account.container.handler;
		self.doChangeFormState(self.emailform, true);
		if (obj.responseText != 'ok') {
			self.showError('emailerr', obj.responseText);
		}
		else {
			self.showError('emailerr', 'E-mail updated successfully');
			self.emailform.cemail.value = self.emailform.email.value;
			self.emailform.email.value = '';
		}
	},
	
	updateEmail: function() {
	
		var self = YAHOO.account.container.handler;
		self.emailform.email.value = self.trim(self.emailform.email.value);
		if (self.emailform.email.value.length == 0) {
			self.showError('emailerr', 'New e-mail could not be empty');
			return;
		}
		
		if (self.emailform.cemail.value.toLowerCase() == self.emailform.email.value.toLowerCase()) {
			return;
		}
		
		self.hideError('emailerr');
		
		var callback = {
			success: self.onEmailResponse,
			failure: self.onRequestFailed
		};
		
		var url = self.base + 'account/update/email/';
		YAHOO.util.Connect.setForm(self.emailform);
		YAHOO.util.Connect.asyncRequest('POST', url, callback);
		self.doChangeFormState(self.emailform, false);
	},
	
	onPayResponse: function(obj) {
		var self = YAHOO.account.container.handler;
		self.doChangeFormState(self.payform, true);
		if (obj.responseText != 'ok') {
			self.showError('payerr', obj.responseText);
		}
		else {
			self.showError('payerr', 'Payment info updated successfully');
			self.payform.pass.value = '';
		}
	},
	
	updatePayment: function() {
		
		var self = YAHOO.account.container.handler;
		var vars = {
			pass: 'Password',
			acc_name: 'Name accountholder',
			acc_city: 'City beneficiary',
			acc_country: 'Country', 
			acc_number: 'Account number beneficiary',
			acc_bank: 'Name bank',
			acc_city_bank: 'City bank',
			acc_code: 'Swift code',
			acc_iban: 'IBAN',
			acc_bic: 'BIC'
		};
		
		for (var i in vars) {
			
			if (!self.payform[i]) {
				continue;
			}
			
			if (self.payform[i].nodeName.toLowerCase() != 'select') {
				self.payform[i].value = self.trim(self.payform[i].value);
			}
			
			if (self.payform[i].value.length == 0 || self.payform[i].value == '0') {
				var errors = {
					en: 'Field \'' + vars[i] + '\' is required',
					nl: '\'' + vars[i] + '\' moet worden ingevuld',
					de: '\'' + vars[i] + '\' muss ausgefüllt werden',
					pl: 'Pole \'' + vars[i] + '\' musi być wypełnione',
					es: '\'' + vars[i] + '\' no puede quedar vacío'
				};
				self.showError('payerr', errors[self._lang]);
				return;
			}
		}
		
		self.hideError('payerr');
		
		var callback = {
			success: self.onPayResponse,
			failure: self.onRequestFailed
		};
		
		var url = self.base + 'account/update/payment/';
		YAHOO.util.Connect.setForm(self.payform);
		YAHOO.util.Connect.asyncRequest('POST', url, callback);
		self.doChangeFormState(self.payform, false);
	},
	
	onPassResponse: function(obj) {
		
		var self = YAHOO.account.container.handler;
		self.doChangeFormState(self.passform, true);
		if (obj.responseText != 'ok') {
			self.showError('passerr', obj.responseText);
		}
		else {
			self.showError('passerr', 'Password updated successfully');
			self.passform.old.value = '';
			self.passform.pass.value = '';
			self.passform.pass_conf.value = '';
		}
	},
	
	updatePass: function() {
		
		var self = YAHOO.account.container.handler;
		if (self.passform.old.value.length == 0) {
			self.showError('passerr', 'You should set old password');
			return;
		}
		
		if (self.passform.pass.value.length < 5) {
			var errors = {
				en: 'Password should contain at least 5 characters',
				nl: 'Het paswoord moet tenminste 5 tekens bevatten',
				de: 'Das Passwort muss mindestenz 5 Zeichen enthalten',
				pl: 'Hasło powinno zawierać co najmniej 5 znaków',
				es: 'Contraseña debe contener al menos 5 caracteres'
			};
			self.showError('passerr', errors[self._lang]);
			return;
		}
		
		if (self.passform.pass.value != self.passform.pass_conf.value) {
			var errors = {
				en: 'Password and password confirmation should be the same',
				nl: 'Paswoord en paswoord bevestiging moeten overeenkomen',
				de: 'Passwort und Passwortbestätigung müssen übereinstimmen',
				pl: 'Twoje hasło i potwierdzenie hasła powinny być takie same',
				es: 'Su contraseña y la confirmación de la misma deben ser iguales'
			};
			self.showError('passerr', errors[self._lang]);
			return;
		}
		
		self.hideError('passerr');
		
		var callback = {
			success: self.onPassResponse,
			failure: self.onRequestFailed
		};
		
		var url = self.base + 'account/update/password/';
		YAHOO.util.Connect.setForm(self.passform);
		YAHOO.util.Connect.asyncRequest('POST', url, callback);
		self.doChangeFormState(self.passform, false);
	},
	
	onAuthResponse: function(obj) {
		
		var self = YAHOO.account.container.handler;
		self.doChangeFormState(self.authform, true);
		if (obj.responseText != 'ok') {
			self.showError('autherr', obj.responseText);
		}
		else {
			document.location.href = self.base + 'account/';
		}
	},
	
	auth: function() {
		
		var self = YAHOO.account.container.handler;
		self.authform.login.value = self.trim(self.authform.login.value);
		/*if (self.authform.login.value.length == 0) {
			self.showError('autherr', 'Username could not be empty');
			return;
		}
		
		if (self.authform.pass.value.length == 0) {
			self.showError('autherr', 'Password could not be empty');
			return;
		}*/
		
		self.hideError('autherr');
		
		var callback = {
			success: self.onAuthResponse,
			failure: self.onRequestFailed
		};
		
		var url = self.base + 'auth/';
		YAHOO.util.Connect.setForm(self.authform);
		YAHOO.util.Connect.asyncRequest('POST', url, callback);
		self.doChangeFormState(self.authform, false);
	},
	
	onRestoreResponse: function(obj) {
		
		var self = YAHOO.account.container.handler;
		self.doChangeFormState(self.remindform, true);
		if (obj.responseText != 'ok') {
			self.showError('reminderr', obj.responseText);
		}
		else {
			self.remindform.style.display = 'none';
			self.remindok.style.display = 'block';
		}
	},
	
	restore: function() {
		
		var self = YAHOO.account.container.handler;
		
		self.remindform.email.value = self.trim(self.remindform.email.value);
		if (self.remindform.email.value.length == 0) {
			self.showError('reminderr', 'E-mail could not be empty');
			return;
		}
		
		self.hideError('reminderr');
		
		var callback = {
			success: self.onRestoreResponse,
			failure: self.onRequestFailed
		};
		
		var url = self.base + 'restore/';
		YAHOO.util.Connect.setForm(self.remindform);
		YAHOO.util.Connect.asyncRequest('POST', url, callback);
		self.doChangeFormState(self.remindform, false);
	},
	
	onResCompleteResponse: function(obj) {
		
		var self = YAHOO.account.container.handler;
		self.doChangeFormState(self.restoreform, true);
		if (obj.responseText != 'ok') {
			self.showError('restoreerr', obj.responseText);
		}
		else {
			document.location.href = self.base + 'account/';
		}
	},
	
	completeRestore: function() {
		
		var self = YAHOO.account.container.handler;
		if (self.restoreform.pass.value.length == 0) {
			var errors = {
				en: 'Password could not be empty',
				nl: 'Het paswoord moet ingevuld worden',
				de: 'Das Passwort muss eingetragen werden',
				pl: 'Pola muszą być wypełnione',
				es: 'Contraseña no puede estar vacío'
			};
			self.showError('restoreerr', errors[self._lang]);
			return;
		}
		if (self.restoreform.pass.value.length < 5) {
			var errors = {
				en: 'Password should contain at least 5 characters',
				nl: 'Het paswoord moet tenminste 5 tekens bevatten',
				de: 'Das Passwort muss mindestenz 5 Zeichen enthalten',
				pl: 'Hasło powinno zawierać co najmniej 5 znaków',
				es: 'Contraseña debe contener al menos 5 caracteres'
			};
			self.showError('restoreerr', errors[self._lang]);
			return;
		}
		if (self.restoreform.pass.value != self.restoreform.pass_conf.value) {
			var errors = {
				en: 'Password and password confirmation should be the same',
				nl: 'Paswoord en paswoord bevestiging moeten overeenkomen',
				de: 'Passwort und Passwortbestätigung müssen übereinstimmen',
				pl: 'Twoje hasło i potwierdzenie hasła powinny być takie same',
				es: 'Su contraseña y la confirmación de la misma deben ser iguales'
			};
			self.showError('restoreerr', errors[self._lang]);
			return;
		}
		
		var callback = {
			success: self.onResCompleteResponse,
			failure: self.onRequestFailed
		};
		
		var url = self.base + 'account/update/password/';
		YAHOO.util.Connect.setForm(self.restoreform);
		YAHOO.util.Connect.asyncRequest('POST', url, callback);
		self.doChangeFormState(self.restoreform, false);
	},
	
	switchForms: function(name) {
		
		var self = YAHOO.account.container.handler;
		
		if (!self[name]) {
			return;
		}
		
		var forms = ['authform', 'remindform'];
		for (var i in forms) {
			
			if (!self[forms[i]]) {
				continue;
			}
			
			if (forms[i] == name) {
				continue;
			}
			
			self[forms[i]].style.display = 'none';
		}
		
		self[name].style.display = 'block';
	},
	
	init: function () {
		if (YAHOO.account.container.handler) {
			return;
		}
		YAHOO.account.container.handler = Account;
		var self = YAHOO.account.container.handler;
		
		try {
			var result = YAHOO.util.Dom.getElementsBy(
				function (elm) { return true; }, 'base'
			);
			if (result && result.length) {
				result = result[0].href;
				if (result.substr(result.length - 1, 1) != '/') {
					result += '/';
				}
				self.base = result;
			}
		} catch (x) { self.base = ''; }
		
		var c = document.cookie;
		c = c.split(/[\s]*;[\s]*/gi);
		if (c && c.length) {
			for (var i = 0; i < c.length; i++) {
				var tmp = c[i].split('=', 2);
				if (!tmp[0] || tmp[0] != 'LANG') {
					continue;
				}
				
				self._lang = tmp[1];
				break;
			}
		}
		else {
			self._lang = 'en';
		}
		
		if (document.forms['reg_form']) {
			self.regform = document.forms['reg_form'];
		}
		self.regerr = YAHOO.util.Dom.get('reg_error');
		self.regok = YAHOO.util.Dom.get('reg_success');
		
		if (document.forms['conf_form']) {
			self.confform = document.forms['conf_form'];
		}
		self.conferr = YAHOO.util.Dom.get('conf_error');
		self.confok = YAHOO.util.Dom.get('reg_success');
		
		if (document.forms['info_form']) {
			self.infoform = document.forms['info_form'];
		}
		self.infoerr = YAHOO.util.Dom.get('info_err');
		
		if (document.forms['email_form']) {
			self.emailform = document.forms['email_form'];
		}
		self.emailerr = YAHOO.util.Dom.get('email_err');
		
		if (document.forms['pay_form']) {
			self.payform = document.forms['pay_form'];
		}
		self.payerr = YAHOO.util.Dom.get('pay_err');
		
		if (document.forms['pass_form']) {
			self.passform = document.forms['pass_form'];
		}
		self.passerr = YAHOO.util.Dom.get('pass_err');
		
		if (document.forms['login_form']) {
			self.authform = document.forms['login_form'];
		}
		self.autherr = YAHOO.util.Dom.get('login_err');
		
		if (document.forms['remind_form']) {
			self.remindform = document.forms['remind_form'];
		}
		self.reminderr = YAHOO.util.Dom.get('remind_err');
		self.remindok = YAHOO.util.Dom.get('remind_ok');
		
		if (document.forms['restore_form']) {
			self.restoreform = document.forms['restore_form'];
		}
		self.restoreerr = YAHOO.util.Dom.get('restore_err');
	}
}

YAHOO.util.Event.addListener(window, "load", Account.init);
//YAHOO.util.Event.addListener(window, "resize", Account.onWndResize);