var resume  = new Resume("Allyson Maciel Guimarães",22); 
resume.start(); 

//Olá, Meu nome é Allyson Maciel Guimarães programador Fullstack e tenho 22 anos. 

/*
FORMAÇÃO: 
	*Colégio Padre Fernando Gomes de Melo  [2011];
	*Universidade Estadual de Goiás        [2012-2015].

HABILIDADES: 
	*Modelagem de dados em banco de dados SQL e NoSQL; 
	*Manuseio de base de dados com MongoDB, Postgress e Mysql; 
	*Modelagem e arquitetura de software; 
	*Construção de aplicações em tempo real;
	*Construir aplicativos mobile com Phonegap;
	*Criar interfaces com Foundation, Bootstrap e afins;   
	*Tomar muito café; 
	*Ter dificuldades pra dormir. 

LINGUAGENS DE PROGRAMAÇÃO: 
	*JavaScript (também com Node.js, avançado); 
	*C e C#     (noções básicas); 
	*Java       (desktop e web); 
	*R e Octave (noções básicas); 
	*PHP        (avançado).

CERTIFICADOS: 
	*R Programming, Universidade Johns Hopkins by Coursera; 
	*Machine Learning, Universidade Stanford by Coursera; 
	*TOEFL ITP; 
	*TO-DO: Full Stack Web Development, Universidade de Ciência e Tecnologia de Hong Kong by Coursera. 

SISTEMAS OPERACIONAIS: 
	*Windows (uso desde que nasci); 
	*Linux   (sei resolver os problemas nele). 

MEUS PROJETOS PESSOAIS: 
	*YoutubeSession (JavaScript + Node.js + MongoDB); 
	*Luwitter (JavaScript + Node.js + MongoDB); 
	*EgressoOnline_PHP (PHP + Mysql); 
	*FerretOut (Java SE); 
	*BotIRCnode (JavaScript + Node.js); 
	*BotIRC (Java SE). 
	*Shorturl (PHP + Mysql). 
*/

//Agora eu vou codificar um pouco em JavaScript, see you later. 
//LOL

var Util = function(){}

Util.prototype.hasEmpty = function(array){
	if( !(array instanceof Array) ) 
	return true; 

	for(var i = 0; i < array.length; i++ )
	if(array[i] == null || typeof array[i] == 'undefined' || array[i] == '')
	return true; 
	
	return false;
}

module.exports = Util; 

var express    = require('express'); 
var route      = express.Router(); 
var Technician = require('../../schema/technician'); 
var Util       = require('../../util/util'); 

route.get('/login', function(req, res, next){
	res.render('login.html'); 
}); 

route.post('/login', function(req, res, next){
	var dd  	 = req.body.ddd; 
	var phone 	 = req.body.phone; 
	var password = req.body.password; 
	var session  = req.session;  

	var util = new Util(); 

	var paramArray = new Array(dd, phone, password); 

	if(util.hasEmpty(paramArray)){
		res.json({status: false, msg: "Dados insuficientes para efetuar login."}); 
		return; 
	}

	Technician.findOne({
		dd: dd, 
		phone: phone, 
		password: password
	},function(error, tech){
		if(error){
			res.json({status: false, msg: error.errmsg}); 
			return; 
		}

		if(tech == null ){
			res.json({status: false, clean_input: true,  msg: "DDD, celular ou senha inválido."}); 
			return; 
		}

		session._id            = tech._id; 
		session._name 		   = tech.name;
		session._authenticated = true; 

		res.json({status: true, redirect : '/dashboard_c'})
	}); 
}); 

module.exports = route; 

var express    = require('express'); 
var route      = express.Router(); 
var Client     = require("../schema/client"); 
var Order      = require("../schema/order"); 
var enumOrder  = require("../enum/enumOrder"); 
var DeliveryPcBotHandler = require("../modules/DeliveryPcBotHandler");

route.post('/createSolicitation', function(req, res,next){
	var api_key 		   = req.body.api_key; 
	var gps_location 	   = req.body.gps_location; 
	var address_complement = req.body.address_complement;  

	if( typeof api_key == 'undefined' || typeof gps_location == 'undefined' || typeof address_complement == 'undefined'){
		res.json({status: false, msg: "You need a little more of date for do it."}); 
		return; 
	}

	//Finding client by api_key
	Client.findOne({
		api_key: api_key
	},function(error,client){
		if(error){
			res.json({status: false, msg: error.errmsg}); 
			return;
		}

		if(client == null){
			res.json({status: false, msg: "notfound"}); 
			return; 
		}

		//Finding open orders by client object Id.
		Order.find({
			client: client._id, 
			status: { $ne : enumOrder.CLOSE }
		},function(error, orders){
			if(error){
				res.json({status: false, msg: error.errmsg}); 
				return;
			}

			//Setting all open orders to status close. 
			for(var i = 0; i < orders.length; i++){
				orders[i].status = enumOrder.CLOSE; 
				orders[i].save(); 
			}

			var order = new Order({
				address_complement: address_complement, 
				gps_location: gps_location, 
				client: client._id, 
				status: enumOrder.OPEN, 
				creation_date: new Date()
			}); 

			order.save(function(error,order){
				if(error){
					res.json({status: false, msg: error.errmsg}); 
					return;
				}

				res.json({status: true}); 
				DeliveryPcBotHandler.pulseSolicitationAlert(); 
			}); 
		}); 
	}); 
}); 	

module.exports = route; 


var Room = function(){
	this.room_owner = 'undefined'; 
	this.intervalTimeout = null;
	this.DELAY = 1000; //one second; 
	this.EXCLUSION_DELAY_BOUND = 3 //three seconds. 
	
	this.started = false; 
	this.play = false;

	this.video_duration  = -1; 
	this.timeout_session =  0; 

	this.users = []; 

	this.usersTyping = new Array(); 
}; 

Room.prototype.whoIsTyping = function(name){
	var is  = "está"; 
	var are = "estão"; 

	var temp  = ""; 
	var count = 0; 
	for( var a = 0 ; a < this.usersTyping.length; a++){
		if(this.usersTyping[a] != name){

			if( this.usersTyping.length > 2 && (a + 1 != this.usersTyping.legth))
				temp += ""+this.usersTyping[a]+", "; 
			else
				temp += ""+this.usersTyping[a]+" e "; 

			count++; 
		}
	}

	if(temp == "") return ""; 

	if(count < 4)
		temp = temp.substring(0,temp.length-2); 
	else
		temp = "muitos"; 
	
	if(count < 2 )
		temp += " "+is+" digitando..."; 
	else
		temp += " "+are+" digitando...";
	return temp; 
}

Room.prototype.addUserFromTypingList = function(name){
	this.usersTyping.push(name); 
	console.log(this.usersTyping); 
}; 

Room.prototype.removeUserFromTypingList = function(name){
	var idx = this.usersTyping.indexOf(name); 
	if(idx != -1)
		this.usersTyping.splice(idx,1); 
}; 

Room.prototype.isSynchronized = function(clientCurrentTime){
	if( clientCurrentTime >= this.timeout_session-this.EXCLUSION_DELAY_BOUND 
	&&  clientCurrentTime <= this.timeout_session+this.EXCLUSION_DELAY_BOUND)
		return true; 
	return false;	
}; 	

Room.prototype.newUser = function(hashName, nome){
	this.users[hashName] = nome; 
}; 

Room.prototype.removeUser = function(hashName){
	delete this.users[hashName]; 
}; 

Room.prototype.getAllUsers = function(){
	return this.users; 
}; 

Room.prototype.isPlay  = function(){
	return this.play; 
}; 

Room.prototype.getTimeout = function(){
	return this.timeout_session; 
}; 

Room.prototype.setPlay = function(){
	if(!this.play)
		this.play = true;
}; 

Room.prototype.setPause = function(){
	if(this.play)
		this.play = false; 
}; 

Room.prototype.registerSessionName = function(session_name){
	this.session_name = session_name; 
}; 

Room.prototype.setProperties = function(link_video,room_name){
	this.link_video = link_video; 
	this.room_name  = room_name;  
}; 

Room.prototype.registerOwner = function(hash){	
	this.room_owner = hash; 
	console.error("usuário registrado como proprietário"+ hash); 
}; 

Room.prototype.ownerExists = function(){
	return (this.room_owner != 'undefined' ); 
}; 

Room.prototype.isOwner = function(hash){
	return (this.room_owner == hash ); 
}; 

Room.prototype.isStarted = function(){
	console.log('isStarted' + this.started); 
	return this.started; 
}; 

Room.prototype.startSession = function(hashOwner, video_duration){
	if(hashOwner != this.room_owner) return false; 
	this.started = true; 
	this.video_duration  = parseInt(video_duration); 
	var self = this; 

	this.intervalTimeout = setInterval(function(){
		if(self.timeout_session <= self.video_duration){
			if(self.play)self.timeout_session += 1;//one second 	
		}
		console.log('time courrent: '+ self.timeout_session +" duration : " + self.video_duration +" play "+ self.play); 
	},this.DELAY); 

	return true; 
}; 

Room.prototype.seekTimeout = function(hashOwner,time){
	if(hashOwner != this.room_owner) return false; 
	this.timeout_session = parseInt(time); 
	return true; 
}; 


module.exports = Room; 

var Server   = require('socket.io');
var CryptoJS = require("crypto-js"); 
var Room     = require('./Room'); 
var Factory  = require('./Factory'); 


var socketServer ={}; 

socketServer.init = function(server) {
	socketServer.io = null; 
	socketServer.rooms = [];
	socketServer.io = io = new Server (server); 

	socketServer.factory = new Factory(); 

	console.log('!Servidor socket iniciado.'); 
	io.on('connection', function(socket){

		socket.on('enterRoom',function(data){
			// console.log("usuário registrando sala na sala: " + data.room); 

			//Registrando usuário na sala específica. 
			socket.__room = data.room; 

			var userHashName = CryptoJS.MD5( new Date().toString()).toString();
			
			socket.hashName =  userHashName; 
			socket.join(data.room); 

			//alimentando array de usuários: 
			var nameTemp = socketServer.factory.names(); 
			socket.name = nameTemp; 

			var currentRoom = socketServer.rooms[socket.__room]; 
			//Enviando informações da sala para o usuário: 

			var allUsers = currentRoom.getAllUsers();
			var users = new Array();

			for(var key in allUsers){
				var user = {};
				user.hashName = key; 
				user.name     = allUsers[key]; 

				users.push(user); 
			}
	
			var roomInfo = {
				linkVideo: currentRoom.link_video,
				roomName : currentRoom.room_name, 
				users    : users, 
				play     : currentRoom.isPlay(), 
				timeout  : currentRoom.getTimeout()+4//Player começar a avançar 4 segunda a frente 
			}; 

			socket.emit('getRoomInfo',roomInfo); 

			//Enviando informações do novo usuário na sala: 
			var userInfo = {
				hashName : socket.hashName, 
				name     : nameTemp
			}; 
			currentRoom.newUser(socket.hashName, socket.name); 
			io.sockets.in(socket.__room).emit('newUser',userInfo); 
		}); 


		//msg protocol: { userName : string, msg : string }
		socket.on('msg',function(data){
			console.log("mensagem em broadcast para a sala "+ socket.__room);
			
			var msgBuild ={
				userName: socket.name, 
				msg     : data.msg
			}; 
			io.sockets.in(socket.__room).emit('msg',msgBuild); 
		}); 

		socket.on('disconnect', function(){
			var userInfo = {
				hashName : socket.hashName, 
				name     : socket.name
			}; 
			// delete socketServer[socket.hashName]; 
			var currentRoom = socketServer.rooms[socket.__room]; 
			currentRoom.removeUser(socket.hashName); 

			io.sockets.in(socket.__room).emit('leave',userInfo); 

			
			//Se o adminstrador da sala sair, um usuário deve ser sorteado como adminstrador.
			if(!currentRoom.isOwner(socket.hashName))
				return; 

			var users = currentRoom.getAllUsers(); 

			var index = Math.floor( Math.random() * users.length); 
			
			currentRoom.registerOwner(tempSocket.hashName); 
			console.log("Nome do dono da sala: agora. "+tempSocket.name); 
			var msgBuild ={
				userName:  'Server', 
				msg     :  'O usuário '+tempSocket.name+' é o novo adminstrador da sala.'
			}; 
			io.sockets.in(tempSocket.__room).emit('msg',msgBuild); 
		});

		socket.on('registerOwner', function(){
			if(socket.__room == 'undefined') return; 
			
			//Adicionando proprietário da sala: 
			if(!socketServer.rooms[socket.__room].ownerExists())
				socketServer.rooms[socket.__room].registerOwner(socket.hashName); 
			else
				return; 

			var msgBuild ={
				userName:  socket.name, 
				msg     : 'Registrado como proprietário da sala'
			}; 
			io.sockets.in(socket.__room).emit('msg',msgBuild); 
		});

		socket.on('onPlay',function(data){
			console.log("onPlay" ); 
			

			socketServer.avatarStatusChange('Play',socket.hashName,socket.__room);  

			var currentRoom = socketServer.rooms[socket.__room]; 
			//executar o comando apenas se o socket for do proprietário: 
			if(!currentRoom.isOwner(socket.hashName))return;

			io.sockets.in(socket.__room).emit('onPlay');

			if(!currentRoom.isStarted()) 
				currentRoom.startSession(socket.hashName, data.duration);  
			currentRoom.setPlay(); 
			
			var msgTemp = {
				userName : socket.name, 
				msg      : "Alguém acabou de dar play"
			}; 
			io.sockets.in(socket.__room).emit('msg',msgTemp); 
		}); 

		socket.on('onPause',function(data){
			console.log("onPause" ); 
			socketServer.avatarStatusChange('Pause',socket.hashName,socket.__room);  

			var currentRoom = socketServer.rooms[socket.__room]; 
			//executar o comando apenas se o socket for do proprietário: 
			if(!currentRoom.isOwner(socket.hashName))return;

			io.sockets.in(socket.__room).emit('onPause'); 
			currentRoom.setPause(); 
				var msgTemp = {
				userName : socket.name, 
				msg      : "Alguém acabou de dar pause"
			}; 
			io.sockets.in(socket.__room).emit('msg',msgTemp); 
		}); 

		socket.on('onSeek',function(data){
			console.log("onSeek" ); 
			var currentRoom = socketServer.rooms[socket.__room]; 
			//executar o comando apenas se o socket for do proprietário: 
			if(!currentRoom.isOwner(socket.hashName))return;
			currentRoom.seekTimeout(socket.hashName, data.time); 
			socket.broadcast.to(socket.__room).emit('onSeek',{time : data.time});

			var msgTemp = {
				userName : 'Server', 
				msg      : "Alterou a posição do vídeo."
			}; 
			io.sockets.in(socket.__room).emit('msg',msgTemp); 
		}); 

		socket.on('onStop',function(data){
			console.log("onStop" ); 

			socketServer.avatarStatusChange('Stop',socket.hashName,socket.__room);  

			//executar o comando apenas se o socket for do proprietário: 
			if(!socketServer.rooms[socket.__room].isOwner(socket.hashName))return;
			io.sockets.in(socket.__room).emit('onStop'); 
			
			var msgTemp = {
				userName : socket.name, 
				msg      : "Alguém acabou de dar stop"
			}; 
			io.sockets.in(socket.__room).emit('msg',msgTemp); 
		}); 

		socket.on('onBuffering',function(data){
			console.log("onBuffering" ); 
			socketServer.avatarStatusChange('Buffering',socket.hashName,socket.__room); 

			//executar o comando apenas se o socket for do proprietário: 
			if(!socketServer.rooms[socket.__room].isOwner(socket.hashName))return;
			io.sockets.in(socket.__room).emit('onBuffering'); 
			var msgTemp = {
				userName : socket.name, 
				msg      : "Alguém acabou de dar buffering"
			}; 
			io.sockets.in(socket.__room).emit('msg',msgTemp); 
		}); 

		socket.on('onThumbUp', function(){
			console.log('onThumbUp'); 
			var msgTemp = {
				userName : socket.name, 
				msg      : ""
			}

			io.sockets.in(socket.__room).emit('msg',msgTemp); 
			socketServer.avatarStatusChange('ThumbUp',socket.hashName,socket.__room); 
		}); 

		socket.on('typeBegin', function(){
			var currentRoom = socketServer.rooms[socket.__room]; 
			currentRoom.addUserFromTypingList(socket.name); 
			var msg = currentRoom.whoIsTyping(); 
			var msgTemp ={
				msg : msg
			};

			io.sockets.in(socket.__room).emit('changeTyping',msgTemp); 
		}); 

		socket.on('typeEnd',function(){
			var currentRoom = socketServer.rooms[socket.__room]; 
			currentRoom.removeUserFromTypingList(socket.name); 
			var msg = currentRoom.whoIsTyping(); 
			var msgTemp ={
				msg : msg
			};

			io.sockets.in(socket.__room).emit('changeTyping',msgTemp); 
		}); 

		socket.on('verifySynchronization',function(data){
			var currentRoom = socketServer.rooms[socket.__room]; 

			if(!currentRoom.isSynchronized(data.currentTime) &&
				currentRoom.isStarted()                    ){
				//
				socket.emit('onSeek',{time : currentRoom.getTimeout()}); 
				var msgTemp = {
					userName : 'Server', 
					msg      : "Seu player foi sincronizado com o servidor."
				}; 
				socket.emit('msg',msgTemp); 
			}
		}); 	
	}); 

socketServer.roomExists = function(hashId){
	return ( this.rooms[hashId] != null  );
}

socketServer.avatarStatusChange = function(action,hashName,room){
	var avatarChange = {
		hashName :   hashName, 
		action   :   action
	};
	io.sockets.in(room).emit('avatarStatusChange', avatarChange); 
}; 

socketServer.createRoom = function(name,url){
	console.log(this.rooms); 
	
		//criando hash para a sala: 
		var data     = new Date().toString(); 
		var hashName = CryptoJS.MD5(name + data).toString(); 

		this.rooms[hashName] = new Room();  

		this.rooms[hashName].registerSessionName(hashName);
		this.rooms[hashName].setProperties(name,url); 
		console.log(this.rooms[hashName]); 

		return hashName; 
	}; 

	socketServer.deleteRoom = function(hashNames){
		delete this.rooms[hashName]; 
	}; 
}; 

module.exports = socketServer;