package {
	import flash.events.MouseEvent;
	
	// Responsável por interagir com usuário e interpretar seus comandos
	public class Usuario {
		public static var restantes:Array;
		public static var indice:int;
		public static var proporcao:Number;
		public static var cartas_selecionadas:Array;
		public static var jogando:Boolean;
		public static var terra_origem:Territorio;
		public static var terra_alvo:Territorio;
		public static var atacando:Boolean;
		public static var movendo_ataque:Movimento;
		public static var ultimo_ataque:Movimento;
		public static var jogando_por_mim:Boolean;
		
		// Permite ao jogador colocar seus exércitos no mundo
		public static function colocar():void {
			Grafica.root.bt_jogue_por_mim.visible = true;
			
			// Pega o número de exércitos
			restantes = Reguladora.calcular_continentes();
			restantes.unshift(Reguladora.calcular_direito());
			indice = 0;
			proporcao = 0;
			jogando = false;
			
			// Ajusta o slider
			Grafica.root.slider_num.maximum = restantes[0];
			Grafica.root.slider_num.value = 1;
			Grafica.root.txt_colocar.text = "001";
			Grafica.root.txt_restantes.text = Reguladora.formatar_num(restantes[0], 3);
		}
		
		// Permite ao jogador fazer troca
		public static function trocar():void {
			Grafica.root.bt_jogue_por_mim.visible = true;
			
			// Se não pode trocar, então pula essa etapa
			if (!Reguladora.pode_trocar()) {
				(new Movimento(Movimento.NAO_TROCAR)).executar();
			} else {
				// Deixa o jogador trocar (ou não)
				jogando = false;
				if (Relacao.get_relacoes(Reguladora.vez, Relacao.CARTA).length>=5) {
					mostrar_cartas();
				}
			}
		}
		
		// Permite ao jogador atacar
		public static function atacar():void {
			Grafica.root.bt_jogue_por_mim.visible = true;
			
			jogando = false;
			atacando = false;
			movendo_ataque = null;
			terra_origem = null;
			terra_alvo = null;
		}
		
		// Exibe a janela de troca
		public static function mostrar_cartas(pagina:int=0):void {
			var todas_cartas:Object, cartas:Array, i:int, max_indice:int;
			
			// Mostra a janela
			Grafica.root.mc_fundo_janelas.visible = true;
			Grafica.root.mc_janela_troca.visible = true;
			
			// Carrega as cartas
			todas_cartas = Relacao.get_relacoes(Reguladora.ativo, Relacao.CARTA);
			max_indice = todas_cartas.length ? Math.floor((todas_cartas.length-1)/5) : 0;
			
			// Define a página
			if (pagina<0) {
				if (indice == 0) {
					indice = max_indice;
				} else {
					indice--;
				}
			} else if (pagina>0) {
				if (indice == max_indice) {
					indice = 0;
				} else {
					indice++;
				}
			} else {
				indice = 0;
				cartas_selecionadas = [];
				for (i=0; i<3; i++) {
					Grafica.root.mc_janela_troca["mc_carta1"+i].gotoAndStop(1);
					Grafica.root.mc_janela_troca["mc_cor1"+i].gotoAndStop(7);
				}
			}
			
			// Carrega as cartas
			cartas = todas_cartas.slice(indice*5, (indice+1)*5);
			
			for (i=0; i<5; i++) {
				Grafica.root.mc_janela_troca["mc_carta0"+i].gotoAndStop(i<cartas.length ? cartas[i].id : 1);
				Grafica.root.mc_janela_troca["mc_cor0"+i].gotoAndStop((i<cartas.length && cartas[i].figura != Carta.BONUS) ? Relacao.get_relacao(cartas[i].territorio, Relacao.DONO).id : 7);
			}
		}
		
		// Seleciona uma carta para troca
		public static function selecionar_carta(e:MouseEvent):void {
			var id:int = e.currentTarget.currentFrame;
			var i:int = 0;
			if (id != 1 && cartas_selecionadas.length<3 && cartas_selecionadas.indexOf(id) == -1) {
				cartas_selecionadas.push(id);
				while (Grafica.root.mc_janela_troca["mc_carta1"+i].currentFrame != 1) {
					i++;
				}
				Grafica.root.mc_janela_troca["mc_carta1"+i].gotoAndStop(id);
				Grafica.root.mc_janela_troca["mc_cor1"+i].gotoAndStop(Grafica.cartas[id-2].figura != Carta.BONUS ? Relacao.get_relacao(Grafica.cartas[id-2].territorio, Relacao.DONO).id : 7);
			}
		}
		
		// Deseleciona uma carta para troca
		public static function deselecionar_carta(e:MouseEvent):void {
			var id:int = e.currentTarget.currentFrame;
			if (id != 1 && cartas_selecionadas.length>0 && cartas_selecionadas.indexOf(id) != -1) {
				cartas_selecionadas.splice(cartas_selecionadas.indexOf(id), 1);
				e.currentTarget.gotoAndStop(1);
				Grafica.root.mc_janela_troca["mc_cor1"+e.currentTarget.name.substr(-1)].gotoAndStop(7);
			}
		}
		
		// Executa a troca
		public static function executar_troca():void {
			var temp:int, cartas:Array;
			if (Reguladora.vez.humano && Reguladora.etapa == Reguladora.TROCA && cartas_selecionadas.length == 3) {
				// Valida a troca
				cartas = [Grafica.cartas[cartas_selecionadas[0]-2], Grafica.cartas[cartas_selecionadas[1]-2], Grafica.cartas[cartas_selecionadas[2]-2]];
				temp = cartas[0].figura*cartas[1].figura*cartas[2].figura;
				if (temp == 2 || temp == 3 || temp == 4 || temp == 9 || temp == 12 || temp == 18) {
					return;
				}
				
				// Pega o número de exércitos
				Reguladora.finalizar_etapa();
				restantes = [Reguladora.trocar(cartas[0], cartas[1], cartas[2])];
				indice = 0;
				proporcao = 0;
				Grafica.root.mc_fundo_janelas.visible = false;
				Grafica.root.mc_janela_troca.visible = false;
				jogando = true;
				
				// Ajusta o slider
				Grafica.root.slider_num.maximum = restantes[0];
				Grafica.root.slider_num.value = 1;
				Grafica.root.txt_colocar.text = "001";
				Grafica.root.txt_restantes.text = Reguladora.formatar_num(restantes[0], 3);
			}
		}
		
		// Permite ao jogador mover exércitos após o ataque
		public static function mover_ataque(mov:Movimento):void {
			movendo_ataque = mov;
		}
		
		// Repete o ataque
		public static function repetir_ataque():void {
			var mov:Movimento, ganhou:Boolean, tempo:int;
			
			// Inicia o ataque
			if (terra_origem) {
				Grafica.atualizar_territorio(terra_origem);
			}
			if (terra_alvo) {
				Grafica.atualizar_territorio(terra_alvo);
			}
			terra_origem = ultimo_ataque.origem;
			terra_alvo = ultimo_ataque.alvo;
			jogando = true;
			atacando = true;
			mov = new Movimento(Movimento.ATACAR);
			mov.origem = terra_origem;
			mov.alvo = terra_alvo;
			mov.num = Math.min(3, terra_origem.soldados-1);
			ganhou = mov.simular();
			tempo = mov.executar();
			if (ganhou) {
				// O jogador ganhou o jogo
				(new Movimento(Movimento.FIM_ETAPA)).executar(tempo);
			} else {
				Reguladora.timeout(function ():void {Usuario.atacando = false;}, tempo, false);
			}
			terra_origem = null;
			terra_alvo = null;
		}
		
		// Permite ao jogador mover seus exércitos
		public static function mover():void {
			Grafica.root.bt_jogue_por_mim.visible = true;
			
			jogando = false;
			terra_alvo = null;
			terra_origem = null;
			proporcao = 0;
		}
		
		// Responde a um clique num território
		public static function botao_territorio(e:MouseEvent):void {
			var alvo:Territorio = Grafica.get_territorio_by_mc(e.currentTarget.name);
			var mov:Movimento, ganhou:Boolean, tempo:int;
			var num:int;
			
			if (Grafica.editando_mundo) {
				// Retira o efeito anterior
				if (Reguladora.alvo_edicao) {
					Grafica.atualizar_territorio(Reguladora.alvo_edicao);
				}
				
				// Carrega o novo formulário
				Reguladora.alvo_edicao = alvo;
				Grafica.atualizar_territorio(Reguladora.alvo_edicao, {"fundo" : 5});
				Grafica.root.mc_edicao.txt_territorio.text = Reguladora.alvo_edicao.nome;
				Grafica.root.mc_edicao.combo_cor.enabled = true;
				Grafica.root.mc_edicao.combo_cor.selectedIndex = Relacao.get_relacao(Reguladora.alvo_edicao, Relacao.DONO).id-1;
				Grafica.root.mc_edicao.slider_soldados.enabled = true;
				Grafica.root.mc_edicao.slider_soldados.value = Reguladora.alvo_edicao.soldados;
			} else if (Reguladora.vez.humano) {
				if (Reguladora.etapa == Reguladora.DIREITO || Reguladora.etapa == Reguladora.CONTINENTE || Reguladora.etapa == Reguladora.TROCA2) {
					// Coloca os exércitos no território pedido
					if (!Relacao.tem_relacao(alvo, Reguladora.vez, Relacao.DONO)) {
						return;
					} else if (indice>0 && !Relacao.tem_relacao(alvo, Grafica.continentes[indice-1], Relacao.CONTINENTE)) {
						return;
					}
					num = int(Math.min(Grafica.root.slider_num.value, restantes[indice]));
					alvo.soldados += num;
					Grafica.atualizar_territorio(alvo, {"delta" : null, "fundo" : 2, "aviso" : true});
					restantes[indice] -= num;
					jogando = true;
					
					// Atualiza o slider
					Grafica.root.txt_restantes.text = Reguladora.formatar_num(restantes[indice], 3);
					Grafica.root.slider_num.value = Math.min(restantes[indice], Grafica.root.slider_num.value);
					Grafica.root.txt_colocar.text = Reguladora.formatar_num(Grafica.root.slider_num.value, 3);
					Grafica.root.slider_num.maximum = restantes[indice];
					
					// Continua o jogo
					if (restantes[indice] == 0) {
						if (indice == 0 && Reguladora.etapa != Reguladora.TROCA2) {
							Reguladora.finalizar_etapa();
						}
						
						for (; indice<restantes.length; indice++) {
							if (restantes[indice]) {
								break;
							}
						}
						
						// Sem mais exércitos para colocar
						if (indice == restantes.length) {
							Reguladora.finalizar_etapa();
						} else {
							Grafica.atualizar_territorios();
							Grafica.destacar_continente(Grafica.continentes[indice-1]);
							Grafica.root.slider_num.maximum = restantes[indice];
							Grafica.root.slider_num.value = int(Math.max(1, restantes[indice]*proporcao));
							Grafica.root.txt_colocar.text = Reguladora.formatar_num(Grafica.root.slider_num.value, 3);
							Grafica.root.txt_restantes.text = Reguladora.formatar_num(restantes[indice], 3);
						}
					}
				} else if (Reguladora.etapa == Reguladora.ATACAR && movendo_ataque) {
					// Move os exércitos após um ataque bem sucedido
					if (alvo == movendo_ataque.origem) {
						movendo_ataque.origem.soldados--;
						movendo_ataque.alvo.soldados++;
						Grafica.atualizar_territorio(movendo_ataque.origem, {"delta" : -1});
						Grafica.atualizar_territorio(movendo_ataque.alvo, {"delta" : 1, "aviso" : true});
			
						// Som
						if (Reguladora.velocidade>Math.random()) {
							(new SomMover).play();
						}
					}
					if (alvo != movendo_ataque.origem || movendo_ataque.origem.soldados == 1 || movendo_ataque.alvo.soldados == movendo_ataque.num) {
						// Para de mover
						Grafica.atualizar_territorio(movendo_ataque.origem);
						Grafica.atualizar_territorio(movendo_ataque.alvo);
						movendo_ataque = null;
					}
				} else if (Reguladora.etapa == Reguladora.ATACAR && !atacando) {
					// Seleciona os territórios envolvidos num ataque
					if (Relacao.tem_relacao(alvo, Reguladora.vez, Relacao.DONO)) {
						// Clicou em território próprio
						if ((terra_alvo == null || Relacao.tem_relacao(terra_alvo, alvo, Relacao.VIZINHO)) && alvo.soldados>1) {
							if (terra_origem) {
								Grafica.atualizar_territorio(terra_origem);
							}
							terra_origem = alvo;
							Grafica.atualizar_territorio(alvo, {"fundo" : 3});
						}
					} else {
						// Clicou no território a ser atacado
						if (terra_origem == null || Relacao.tem_relacao(terra_origem, alvo, Relacao.VIZINHO)) {
							if (terra_alvo) {
								Grafica.atualizar_territorio(terra_alvo);
							}
							terra_alvo = alvo;
							Grafica.atualizar_territorio(alvo, {"fundo" : 4});
						}
					}
					
					// Inicia o ataque
					if (terra_origem != null && terra_alvo != null) {
						jogando = true;
						atacando = true;
						mov = new Movimento(Movimento.ATACAR);
						mov.origem = terra_origem;
						mov.alvo = terra_alvo;
						mov.num = Math.min(3, terra_origem.soldados-1);
						ganhou = mov.simular();
						tempo = mov.executar();
						if (ganhou) {
							// O jogador ganhou o jogo
							(new Movimento(Movimento.FIM_ETAPA)).executar(tempo);
						} else {
							Reguladora.timeout(function ():void {Usuario.atacando = false;}, tempo, false);
						}
						terra_origem = null;
						terra_alvo = null;
					}
				} else if (Reguladora.etapa == Reguladora.MOVER) {
					// Seleciona os territórios envolvidos num movimento
					if (Relacao.tem_relacao(alvo, Reguladora.vez, Relacao.DONO)) {
						// Clicou em território próprio
						if (terra_alvo == null) {
							// Define o alvo
							terra_alvo = alvo;
							Grafica.atualizar_territorio(alvo, {"fundo" : 4});
							return;
						} else if (terra_origem == null && alvo.livres>0 && Relacao.tem_relacao(alvo, terra_alvo, Relacao.VIZINHO)) {
							// Define a origem
							terra_origem = alvo;
							Grafica.atualizar_territorio(terra_origem, {"fundo" : 5});
							Grafica.root.slider_num.maximum = terra_origem.livres;
							Grafica.root.slider_num.value = int(Math.max(1, terra_origem.livres*proporcao));
							Grafica.root.txt_colocar.text = Reguladora.formatar_num(Grafica.root.slider_num.value, 3);
							return;
						} else if (alvo == terra_origem) {
							// Move os exércitos
							jogando = true;
							num = Grafica.root.slider_num.value;
							terra_alvo.soldados += num;
							Grafica.atualizar_territorio(terra_alvo, {"delta" : num, "aviso" : true});
							terra_origem.soldados -=num;
							Grafica.atualizar_territorio(terra_origem, {"delta" : -num, "aviso" : true});
							terra_origem.livres -= num;
					
							// Atualiza o slider
							Grafica.root.slider_num.value = Math.min(terra_origem.livres, Grafica.root.slider_num.value);
							Grafica.root.txt_colocar.text = Reguladora.formatar_num(Grafica.root.slider_num.value, 3);
							Grafica.root.slider_num.maximum = terra_origem.livres;
					
							// Som
							if (Reguladora.velocidade>Math.random()) {
								(new SomMover).play();
							}
							
							if (terra_origem.livres>0) {
								return;
							}
						}
					}
					
					// Deseleciona tudo
					if (terra_alvo) {
						Grafica.atualizar_territorio(terra_alvo);
						if (terra_alvo.livres != terra_alvo.soldados-1) {
							Grafica.atualizar_territorio(terra_alvo, {"fundo" : 2});
						}
						terra_alvo = null;
					}
					if (terra_origem) {
						Grafica.atualizar_territorio(terra_origem);
						if (terra_origem.livres != terra_origem.soldados-1) {
							Grafica.atualizar_territorio(terra_origem, {"fundo" : 2});
						}
						terra_origem = null;
					}
					
					// Se for o caso, seleciona o novo território
					if (Relacao.tem_relacao(alvo, Reguladora.vez, Relacao.DONO)) {
						Grafica.root[alvo.mc].dispatchEvent(e);
					}
				}
			}
		}
	}
}