# -*- coding: utf-8 -*-

from __future__ import unicode_literals

import math

DESTRUIDO = 'Destruido'
ATIVO = 'Ativo'
GRAVIDADE = 10  # m/s^2


class Ator():
    """
    Classe que representa um ator. Ele representa um ponto cartesiano na tela.
    """
    _caracter_ativo = 'A'
    _caracter_destruido = ' '

    def __init__(self, x=0, y=0):
        """
        Mtodo de inicializao da classe. Deve inicializar os parmetros x, y, caracter e status

        :param x: Posio horizontal inicial do ator
        :param y: Posio vertical inicial do ator
        """
        self.y = y
        self.x = x
        self.status = ATIVO

    def caracter(self):
        return self._caracter_ativo if self.status == ATIVO else self._caracter_destruido

    def calcular_posicao(self, tempo):
        """
        Mtodo que calcula a posio do ator em determinado tempo.
        Deve-se imaginar que o tempo comea em 0 e avana de 0,01 segundos

        :param tempo: o tempo do jogo
        :return: posio x, y do ator
        """
        return 1, 1

    def colidir(self, outro_ator, intervalo=1):
        """
        Mtodo que executa lgica de coliso entre dois atores.
        S deve haver coliso se os dois atores tiverem seus status ativos.
        Para coliso,  considerado um quadrado, com lado igual ao parmetro intervalo, em volta do ponto onde se
        encontra o ator. Se os atores estiverem dentro desse mesmo quadrado, seus status devem ser alterados para
        destruido, seus caracteres para destruido tambm.

        :param outro_ator: Ator a ser considerado na coliso
        :param intervalo: Intervalo a ser considerado
        :return:
        """
        pass


class Obstaculo(Ator):
    pass


class Porco(Ator):
    pass


class DuploLancamentoExcecao(Exception):
    pass


class Passaro(Ator):
    velocidade_escalar = 10

    def __init__(self, x=0, y=0):
        """
        Mtodo de inicializao de pssaro.

        Deve chamar a inicializao de ator. Alm disso, deve armazenar a posio inicial e incializar o tempo de
        lanamento e angulo de lanamento

        :param x:
        :param y:
        """
        super().__init__(x, y)
        self._x_inicial = x
        self._y_inicial = y
        self._tempo_de_lancamento = None
        self._angulo_de_lancamento = None  # radianos

    def foi_lancado(self):
        """
        Mtodo que retorna verdaeira se o pssaro j foi lanado e falso caso contrrio

        :return: booleano
        """
        return True

    def colidir_com_chao(self):
        """
        Mtodo que executa lgica de coliso com o cho. Toda vez que y for menor ou igual a 0,
        o status dos Passaro deve ser alterado para destruido, bem como o seu caracter

        """
        pass

    def calcular_posicao(self, tempo):
        """
        Mtodo que clcula a posio do passaro de acordo com o tempo.

        Antes do lanamento o pssaro deve retornar o valor de sua posio inicial

        Depois do lanamento o pssaro deve calcular de acordo com sua posio inicial, velocidade escalar,
        ngulo de lancamento, gravidade (constante GRAVIDADE) e o tempo do jogo.

        Aps a coliso, ou seja, ter seus status destruido, o pssaro deve apenas retornar a ltima posio calculada.

        :param tempo: tempo de jogo a ser calculada a posio
        :return: posio x, y
        """
        return 1, 1


    def lancar(self, angulo, tempo_de_lancamento):
        """
        Lgica que lana o pssaro. Deve armazenar o ngulo e o tempo de lanamento para posteriores clculo.
        O ngulo  passado em graus e deve ser transformado em radianos

        :param angulo:
        :param tempo_de_lancamento:
        :return:
        """
        pass


class PassaroAmarelo(Passaro):
    pass


class PassaroVermelho(Passaro):
    pass