#! /usr/bin/python
# -*- coding: iso-8859-1 -*-

#####################################################
#    Copyright (C) 2006 by Cesar Kallas   	
#    cesarkallas@soulivre.org   
#    http://cesarkallas.soulivre.org
#                                                                          
#    This program is free software; you can redistribute it and#or modify  
#    it under the terms of the GNU General Public License as published by 
#    the Free Software Foundation; either version 2 of the License, or     
#    (at your option) any later version.                                   
#                                                                          
#    This program is distributed in the hope that it will be useful,       
#    but WITHOUT ANY WARRANTY; without even the implied warranty of        
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         
#    GNU General Public License for more details.                          
#                                                                          
#    You should have received a copy of the GNU General Public License     
#    along with this program; if not, write to the                         
#    Free Software Foundation, Inc.,                                       
#    59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             
#####################################################

import Opcoes
import BancoDados 
import Repositorio
import Grupos
import Operadores
import Acoes
import Agentes
import Ambiente
import Servidor, ServidorWeb, ServidorRPC
import UIConectaGerente as UI
import qt
import sys
import UIAgentes, UIGrupos, UIOperadores, UIRepositorio, UIConectaGerenteLogin, Log
import thread
import time
import os


class InterfaceLogin(object):
	def __init__(self):
		self.uiLogin = UIConectaGerenteLogin.UIConectaGerenteLogin()
		self.__slots()
		self.uiLogin.show()
		self.tentativas = 0
		self.uiLogin.login_lineLogin.setText("administrador")
		self.uiLogin.login_lineSenha.setText("1")
	
	def exibe(self):
		self.uiLogin.show()
		return self.uiLogin
		
	def __slots(self):
		self.uiLogin.connect(self.uiLogin.login_botaoEntrar, qt.SIGNAL('clicked()'), self.__trataBotaoEntrar)
		
	def __trataBotaoEntrar(self):
		login = str(self.uiLogin.login_lineLogin.text())
		senha = str(self.uiLogin.login_lineSenha.text())
		# Faz autenticacao
		operadores = Operadores.Operadores()
		if operadores.autentica(login, senha) == 1:
			Ambiente.operador = login
			self.uiLogin.close()
		else:
			self.tentativas += 1
			qt.QMessageBox.critical(None, "ConectaGerente - Login", qt.QString("Usuário ou senha inválida!"))
			if self.tentativas > 2:
				sys.exit()


class Interface(object):
	"""
	Classe que gerencia a interface grafica
	"""
	
	def __init__(self):
		self.ui = UI.UIConectaGerente()
		self.uiAgentes = UIAgentes.UIAgentes(self.ui)
		self.uiGrupos = UIGrupos.UIGrupos(self.ui)
		self.uiOperadores = UIOperadores.UIOperadores(self.ui)
		self.uiRepositorio = UIRepositorio.UIRepositorio(self.ui)
		self.acoes = Acoes.Acoes(1)
		self.servidor = Servidor.Servidor()
		self.repositorio = Repositorio.Repositorio()
		self.agentes = Agentes.Agentes()
		self.operadores = Operadores.Operadores()
		self.grupos = Grupos.Grupos()
		
		# Inicia atualiza periodica do log
		thread.start_new_thread(self.trataLog,() )
		
		self.__sumario()
		
		
	def __slots(self):
		self.ui.connect(self.ui._botaoSumario, qt.SIGNAL('clicked()'), self.__sumario)
		self.ui.connect(self.ui._botaoFerramentasLog, qt.SIGNAL('clicked()'), self.__log)
		self.ui.connect(self.ui._botaoIniciarServidor, qt.SIGNAL('clicked()'), self.__iniciaServidor)
		self.ui.connect(self.ui._botaoPararServidor, qt.SIGNAL('clicked()'), self.__paraServidor)
		

	def trataLog(self):
		arqLog = open("conecta-gerente.log")
		self.ui.log_listMensagens.clear()
		i = 0
		for linha in arqLog:
			i += 1
			self.ui.log_listMensagens.insertItem(qt.QString(linha), i)
			
		self.ui.log_listMensagens.sort (False)

		while 1:
			time.sleep(3)
			try:
				linha = qt.QString(arqLog.readline())
				if linha:
					i += 1
					self.ui.log_listMensagens.insertItem(linha, i)
			except Exception:
				raise
				continue


	def exibir(self):
		self.ui._botaoIniciarServidor.setEnabled(True)
		self.ui._botaoPararServidor.setEnabled(False)
		self.__slots()
		self.ui.show()
		return self.ui		


	def __log(self):
		# Exibe janela interna de log
		self.ui.widgetStack.raiseWidget(self.ui.wStackLog)


	def __sumario(self):
		# Exibe janela interna de sumario
		self.ui.widgetStack.raiseWidget(self.ui.wStackSumario)
		
		# Atualiza lista de acoes pendentes
		acoesPendentes = self.acoes.exportaTodos("agendada")
		self.ui._tabelaAcoes.setNumRows(0)
		self.ui._tabelaAcoes.setEnabled(True)
		linha = 0
		for acao in acoesPendentes:
			self.ui._tabelaAcoes.insertRows(linha, 1)
			self.ui._tabelaAcoes.setText(linha, 0, qt.QString(str(acao["id"])))
			self.ui._tabelaAcoes.setText(linha, 1, qt.QString(str(acao["acao"])))
			self.ui._tabelaAcoes.setText(linha, 2, qt.QString(str(acao["agentes_mac_address"])))
			self.ui._tabelaAcoes.setText(linha, 3, qt.QString(str(acao["softwares_md5"])))
			self.ui._tabelaAcoes.setText(linha, 4, qt.QString(str(acao["data_execucao"])))
		self.ui._labelOperador.setText(Ambiente.operador)
		
		# Repositorio
		numSoftwares = self.repositorio.total()
		tamanhoRepositorio = self.repositorio.tamanho()
		self.ui._labelSumarioRepositorioSoftwares.setText(str(numSoftwares["numSoftwares"]))
		if tamanhoRepositorio["tam"] == None:
			tamanhoRepositorio["tam"] = 0
		self.ui._labelSumarioRepositorioTamanhoSoftwares.setText(str(int(tamanhoRepositorio["tam"])/1024000) + " MBytes")

		# Agentes
		agentes = self.agentes.total()
		self.ui._labelSumarioAgentes.setText(str(agentes["total"]))
		
		# Operadores
		operadores = self.operadores.total()
		self.ui._labelSumarioOperadores.setText(str(operadores["total"]))
		
		# Grupos
		grupos = self.grupos.total()
		self.ui._labelSumarioGrupos.setText(str(grupos["total"]))


	def __iniciaServidor(self):
		thread.start_new_thread(self.servidor.iniciar,() )
		
		# Inicia servidor web
		servidorWeb = ServidorWeb.ServidorWeb()
		thread.start_new_thread(servidorWeb.iniciar, ("repositorio/", 10501))
		
		# Inicia servidor RPC
		servidorRPC = ServidorRPC.ServidorRPC("", Ambiente.portaRPC)
		thread.start_new_thread(servidorRPC.iniciar, ())
		
		time.sleep(3)
		if Ambiente.servidorOnline == 1:
			qt.QMessageBox.information(None, "Servidor", qt.QString("Servidor iniciado com sucesso!"))
			self.ui._botaoIniciarServidor.setEnabled(False)
			self.ui._botaoPararServidor.setEnabled(True)
			self.ui.label_sumarioServidor.setText("online")
		else:
			qt.QMessageBox.critical(None, "Servidor", qt.QString("Falha ao iniciar o servidor!\nContate o administrador."))
			
	
	def __paraServidor(self):
		Ambiente.servidorOnline = 0
		self.ui.label_sumarioServidor.setText("parando...")


def main():
	# Le as opcoes de inicializacao
	opcoes = Opcoes.Opcoes()

		
	# Conecta no banco de dados
	dbOpcoes = opcoes.ler('BancoDados')
	dbanco = BancoDados.BancoDados(dbOpcoes["host"], dbOpcoes["usuario"], dbOpcoes["senha"], dbOpcoes["base"])
	db = dbanco.conectar()
	
	if db == None:
		print "Falha conectar banco dados."
		return -1

	Ambiente.db = db
	
	log = Log.Log()
	Ambiente.log = log.get()
	
	# Cadastra novo grupo
	grupo = {"nome" : "sala 1", "descricao" : "computadores da sala 1", "responsavel" : "cesar kallas", "classe" : "dell" }
	grupo2 = {"nome" : "padrao", "descricao" : "grupo padrao", "responsavel" : "cesar kallas", "classe" : "puc" }
	grupos = Grupos.Grupos()
	grupos.inseri(grupo)
	grupos.inseri(grupo2)
	#print "Total de grupos: ", grupos.total()
	#print grupos.informacao(grupo["nome"])
	#print grupos.remove(grupo["nome"])
	
	
	# Inicia Repositorio
	#repOpcoes = opcoes.ler('Repositorio')
	#repositorio = Repositorio.Repositorio(repOpcoes['caminho'])
	#repositorio.atualiza()

	
	# Cadastra novo operador
	#operador = { "login" : "cesarkallas", "nome" : "Cesar Henrique Kallas", "nivel" : "Administrador" }
	#operadores = Operadores.Operadores()
	#operadores.inseri(operador)
	#print "Total de operadores: ", operadores.total()
	#Ambiente.operador = operador["login"]
	#print "Operador atual: ", Ambiente.operador
	#print operadores.remove(operador["login"])
	
	# Cadastra novo agente
	agente = {"mac_address" : "00:0B:CD:EC:58:84", "grupos_nome" : grupo["nome"], "host" : "127.0.0.1", "apelido" : "cesarkallas" }
	agentes = Agentes.Agentes()
	agentes.inseri(agente)
	#agente = agentes.informacao(agente["mac_address"])
	#print "Agente cadastrado: ", agente["apelido"], agente["mac_address"], agente["host"]
	
	
	# Cadastra uma nova acao
	#acao = { "softwares_md5" : "eb07010a2f91e45750c2ee9ac882ad48", "data_execucao" : "2006/5/01", "observacao" : "monitor de rede", "agentes_mac_address" : agente["mac_address"]}
	#acoes = Acoes.Acoes(agente["mac_address"])
	#doc = acoes.exporta("agendada")
	#xml.dom.ext.PrettyPrint(doc)
	#acoes.instala(acao)
	#acoes.atualiza(acao)
	#acoes.desinstala(acao)
	#acoes.removeAcao(1)
	
	# Servidor
	#serv = Servidor.Servidor()
	#serv.iniciar()
	
	
	app = qt.QApplication(sys.argv)
	uiLogin = InterfaceLogin()
	app.setMainWidget(uiLogin.exibe())
	app.exec_loop()

	if Ambiente.operador != "":
		# Cria nova aplicacao QT
		#app = qt.QApplication(sys.argv)
		ui = Interface()
		app.setMainWidget(ui.exibir())
		app.exec_loop()
		
	# Fecha conexao com o banco de dados
	dbanco.desconectar()

if __name__ == "__main__":
	main()