/*
 * Main Authentication class. 
 * responsible for:
 *  -Login
 *  -Logout
 *  -Login status
 * 
 * writeen by: Dhimiter Bozo
 */


//responsible for sending request 
//and forwarding responses
var Auth = new Class ({
	Implements: [Events, Options],
	
	initialize: function(options) {
		SBCOM.utils.doLog('Auth: initialize: '+options.username);
		this.setOptions(options);
	},

	handleResult: function(response, callerFunc) {
		SBCOM.utils.doLog('Auth: handleResult (super): '+response);
	},
	
	send: function(url, params){
		SBCOM.utils.doLog('Auth: send: '+url);
		try {
			this.jsonReq = getJSON(url, params, this.handleResult.bind(this));
		} catch (error) {
			SBCOM.utils.doLog('>>>Auth: send: error: '+error);
		}
		return this;
	},

	// Preping nick.com for a JSESSIONID for new users.
	doNickCheck: function(check, username, password) {
		SBCOM.utils.doLog('Auth: doNickCheck: '+check);
		var params = {
			'res':'js',
			'auto':'on',
			't':Math.random()
		};

		if(check) {
			params['login_type'] = 'LOGIN_CHECK';
		} else {
			params['screenName'] = username;
			params['password'] = password;
		}

		var nickLoginUrl = 'http://'+ SBCOM.utils.getNickDomain() +'/common/login/check.jhtml';
		//SBCOM.moojax.json.doRequest(nickLoginUrl, params, this.handleNickCheck.bind(this));

		SBCOM.jquery.doJsonRequest({
			url: nickLoginUrl,
			data: params,
			onFail:function(request, error, exception) {
				SBCOM.utils.doLog("Auth: "+error);
			},
			onSuccess:this.handleNickCheck.bind(this)
		});
	},

	handleNickCheck: function(response) {
		SBCOM.utils.doLog('Auth: handleNickCheck - override');
	}
});

/*
 * Registration.js
 * Registration Class. 
 * Handles user registration for 13- and 14+ users
 * 
 * written by: Dhimiter Bozo
 * 
 */

var Registration = new Class({
	Extends: Auth,
	_response:null,

	options: {
		/*onSuccess: $empty,
		  onFailed: $empty,
		 */
		//default, if not over-written when the object is instantiated 
		url: "/ajax/register/13/",
		username: '',
		password: ''
	},

	initialize: function(options) {
		this._response = null;
		SBCOM.utils.doLog('Registration: initialize: '+options);
		this.parent(options);
	},

	send: function(params) {
		this._response = null;
		SBCOM.utils.doLog('registration: send: ');
		return this.parent(this.options.url, params);
	},
	
	handleResult: function(response, callerFunc) {
		this._response = response;
		SBCOM.utils.doLog('Registration: handleResult: '+response);
		//generic registration success event
		if (response.success == "true")
		{
			SBCOM.utils.doLog('registration: success');
			//this.fireEvent('success', response);
			this.doNickCheck(false, this.options.username, this.options.password);
		}
		//generic registration failed event
		else if (response.loggedIn == "false")
		{
			SBCOM.utils.doLog('registration: false');
			this.fireEvent('failed', response);
		}
	},
	handleNickCheck: function(nickResponse) {
		SBCOM.utils.doLog('Registration: handleNickCheck: '+nickResponse.loggedIn);
		this.fireEvent('success', this._response);
	}
});


/*
 * JoinFlux.js
 * Login Class. 
 * Handles users joining the spongebob flux community
 * 
 * written by: Dhimiter Bozo
 * 
 */

var JoinFlux = new Class({
	Extends: Auth,
	
	options: {
	/*onSuccess: $empty,
		  onFailed: $empty,
	 */
	},
	
	initialize: function(options) {
		SBCOM.utils.doLog('JoinFlux: initialize: ' + options);
		this.parent(options);
	},
	//no params needed
	send: function() {
		SBCOM.utils.doLog('JoinFlux: send: ');
		return this.parent("/ajax/join-community/");
	},
	
	handleResult: function(response, callerFunc) {
		SBCOM.utils.doLog('JoinFLux: handleResult: '+response);
		//join success
		if ((response.loggedIn == "true") && (response.fluxCommunityMember == "true"))
			this.fireEvent('success', response);
		//join failed
		else if ((response.loggedIn == "true") && (response.fluxCommunityMember == "false"))
			this.fireEvent('failed', response);
		//not loggedin
		else if ((response.loggedIn == "false") || (response.fluxCommunityMember == undefined))
			this.fireEvent('notLoggedIn', response);
	}
});

/*
 * Login.js
 * Login Class. 
 * Handles user authentication
 * 
 * written by: Dhimiter Bozo
 * 
 */

var Login = new Class({
	Extends: Auth,
	_response:null,

	options: {
		/*onSuccess: $empty,
		  onFailed: $empty,
		  onNickLogin: $empty,
		  onFluxLogin: $empty,
		 */
		username: '',
		password: '',
		haltReload:false
	},

	initialize: function(options) {
		this._response = null;
		SBCOM.utils.doLog('Login: initialize: '+options.username);
		this.parent(options);
	},

	//expects params in this form: login=[username]&password=[password]
	send: function(params) {
		this._response = null;
		SBCOM.utils.doLog('Login: send: ');
		return this.parent("/ajax/login/", params);
	},
	
	handleResult: function(response, callerFunc) {
		this._response = response;
		SBCOM.utils.doLog('Login: handleResult: '+response.doLoggedIn+" | "+response.loginType);
		//generic login event
		if( response.eventMode == "true" ) {
			this.fireEvent('eventMode', response);
		} else {
			if (response.loggedIn == "true") {
				this.fireEvent('success', response);
			}
			//successful nick authentication event
			if ((response.loggedIn == "true") && (response.loginType == "nick")) {
				//this.fireEvent('nickLogin', response);
				this.doNickCheck(false, this.options.username, this.options.password); // calls nickLogin after
			//successful flux authentication event
			} else if ((response.loggedIn == "true") && (response.loginType == "flux")) {
				this.fireEvent('fluxLogin', response);
			//generic login failed event
			} else if (response.loggedIn == "false") {
				this.fireEvent('failed', response);
			}
		}
	},

	handleNickCheck: function(nickResponse) {
		SBCOM.utils.doLog('Login: handleNickCheck: halt: '+this.options.haltReload+' | '+nickResponse.loggedIn);
		this._response["haltReload"] = this.options.haltReload;
		this.fireEvent('nickLogin', this._response);
	}
});


/*
 * Logout.js
 * Logout Class
 * Handles user de-authentication
 * 
 * written by: Dhimiter Bozo
 * 
 */

var Logout = new Class ({
	Extends: Auth,
	
	options: {
		/*onSuccess: $empty,
		  onFailed: $empty,
		 */
	},
	
	send: function() {
		return this.parent("/ajax/logout/", "");
	},
	
	handleResult: function(response, callerFunc) {
		SBCOM.utils.doLog('Logout: handleResult: '+response);
		//generic logout event
		if (response.loggedIn == "false")
			this.fireEvent('success', response);
		//generic logout failed event
		else if (response.loggedIn == "true")
			this.fireEvent('failed', response);
	}
	
});


/*
 * AuthStatus.js
 * Authentication Status Class
 * Returns the user's authentication status
 * 
 * written by: Dhimiter Bozo
 */

var AuthStatus = new Class ({
	Extends: Auth,
	_queued:null,
	_response:null,
	_pendingNickCheck:false,

	options:{
		/*onStatusLoggedIn: $empty,
		  onStatusLoggedOut: $empty,
		  onFailed: $empty,
		 */
	},

	send: function() {
		this._response = null;
		SBCOM.utils.doLog('AuthStatus: send2');
		return this.parent("/ajax/login-check/", "");
	},

	handleResult: function(response, callerFunc) {
		this._response = response;
		this._pendingNickCheck = false;

		SBCOM.utils.doLog('AuthStatus: handleResult: '+response.loggedIn);

		//logged out event
		if (response.loggedIn == "false") {
			this.fireEvent('statusLoggedOut', this._response);
			this.doQueuedRequests();
		//logged in event
		} else if (response.loggedIn == "true") {
			if(response.loginType == "flux")
			{
				this.fireEvent('statusLoggedIn', this._response);
				this.doQueuedRequests();
			}
			else
			{
				this._pendingNickCheck = true;
				this.doNickCheck(true);
			}
		//generic failed message
		} else {
			this._response.loggedIn = "false";
			this.fireEvent("failed");
			this.doQueuedRequests();
		}
	},

	setResponse: function(response) {
		SBCOM.utils.doLog('AuthStatus: setResponse: '+response);
		if(response == null || response.loggedIn === "false") return;
		this._response = response;
	},

	isLoggedIn: function() {
		return this._response != null &&
			"true" == this._response.loggedIn &&
			!SBCOM.utils.isEmptyString(this._response.screenName);
	},

	getScreenName: function() {
		return this._response == null ? null : this._response.screenName;
	},

	doCheckLogin: function(callback) {
		SBCOM.utils.doLog('Auth: doCheckLogin: pending: '+this._pendingNickCheck);
		if(callback == null) return;

		if(this._response == null || this._pendingNickCheck) {
			SBCOM.utils.doLog('Auth: doCheckLogin: queueing callback: _pendingNickCheck: '+this._pendingNickCheck+" | "+(typeof callback));
			if(this._queued == null) this._queued = new Array();
			this._queued.push(callback);
		} else {
			SBCOM.utils.doLog('Auth: doCheckLogin: executing callback: '+this._pendingNickCheck+' | '+(typeof callback));
			callback(this.isLoggedIn());
		}
	},

	doQueuedRequests: function() {
		if(this._queued == null || this._queued.length <= 0) return;
		SBCOM.utils.doLog('AuthStatus: doQueuedRequests');

		for(var i = 0; i < this._queued.length; i++) {
			if(this._queued[i] == null) continue;
			SBCOM.utils.doLog('AuthStatus: doQueuedRequests: '+i);
			this._queued[i](this.isLoggedIn());
		}
		this._queued = null;
	},

	handleNickCheck: function(nickResponse) {
		this._pendingNickCheck = false;
		SBCOM.utils.doLog('AuthStatus: handleNickCheck: '+nickResponse.loggedIn);

		if(nickResponse.loggedIn === 'true') {
			this.fireEvent('statusLoggedIn', this._response);
		} else {
			/* Reload spongebob.com due to nick.com not responding with a logged in state via json request.
			 * nick.com rebuilds the session on page load to allow login_type:LOGIN_CHECK to function.  
			 */
			logOut.send();
		}
		this.doQueuedRequests();
	}
});