ES - TP1 - Interface das Classes do Jogo

/*
 *  Lembrete de debate:
 *  Discutir os get's e set's
 *
 *  Discutir se a qualidade vai afetar o bonus de um projeto.
 *
 *  Discutir a controladora, tem muita coisa lá para decidirmos.
 *
 *  Discutir se é necessário guardar o turno de termino de uma tarefa.
 *
 *  Pedir para lerem os comentário no final do arquivo.
 *
 */

using System.Collections.Generic;

namespace Controle
{
    public class cTarefa
    {
        public String nome { get; set; }
        public int ID { get; set; }
        public Ambiente.eCategoria tipo { get; set; }

        // A qualidade acumulada da Tarefa é o bonus de qualidade que veio de outras tarefas.
        // Deve ser inicializada com o valor 0.
        public int Qualidade_acumulada { get; set; }

        // Indica se a tarefa já foi completada.
        // Deve ser iniciada como false.
        public bool completada { get; private set; }

        // Guarda o turno em que a tarefa foi completada;
        // Não precisa ser inicializada.
        // Quando ele receber uma chamada ao `set` a variável `completada` será marcada como `true`.
        public int data_do_termino {

            get{return this.data_do_termino;}

            private set { completada = true; data_do_termino = value; }

        }
        // <Nota Garcia> Essa variavel foi requisitada pelo jesus, eu acho que ela pode ser desnecessária. </Nota>

        // Completa a tarefa e seta a `data` para a variável `data_do_termino`
        public void completa_tarefa(int data) { throw new NotImplementedException(); }

        // Construtora, inicia as demais variáveis.
        public cTarefa(int nome, int ID, Ambiente.eCategoria tipo_da_tarefa) { throw new NotImplementedException(); }
    }
}


   /*
     * Comentário Garcia:
     * Pode ser interessante criar uma função serialize e deserialize
     * para podermos guardar os dados de cada projeto nosso em um arquivo.txt
     *
     * Caso agente não faça isso, vamos ter de inicializar cada variável da classe cProjeto
     * e como vão ser uns 10 projetos isso vai poluir muito o código.
     */
    public class cProjeto
    {
        // Um struct que guarda os efeitos positivos ou negativos de completar ou falhar na missão:
        public struct tBuff
        {
            public int repModif;
            public int dinheiroModif;
        }

        // As variáveis abaixo contém o buff e o debuf do projeto.
        // Devem ser inicializadas na construtora.
        public tBuff bonus { get; set; }
        public tBuff penalidade { get; set; }

        // A qualidade acumulada do Projeto é qualidade gerada pelas tarefas
        // que geram bonus diretamente para o projeto.
        // Deve ser inicializada como 0.
        public int qualidade_acumulada { get; set; }

        // Indica o turno limite até onde o projeto pode ser completado.
        public int prazo_do_projeto {get; set;}

        // A lista abaixo deve conter um subconjunto das tarefas pré-fabricadas
        // encontradas em ambiente.getTarefa(int ID).
        public cTarefa[] tarefa;
        public cTarefa getTarefa(int ID) { throw new NotImplementedException(); }
        public void setTarefa(cTarefa tarefa, int ID) { throw new NotImplementedException(); }

        public enum eCompletado { NaoCompletado, CompletadoSucesso, CompletadoFalhou }
        // Inicializado como NaoCompletado:
        public eCompletado completado {get; set;}

        // Inicializa as demais variáveis.
        public cProjeto(tBuff bonus, tBuff penalidade, cTarefa[] tarefas) { throw new NotImplementedException(); }
        public cProjeto() { throw new NotImplementedException(); }
    }


    public class cFuncionario
    {
        //<Nota Garcia> Posso ter esquecido algum dado do funcionário </nota>

        public String nome {get; set;}
        public Ambiente.eCategoria cargo {get; set;}
        public String descricao {get; set;}

        public int salario {get; set;}

        // Guarda a tarefa a ser realizada no próximo turno.
        // Inicializada como vazia.
        cTarefa tarefa_do_turno {get; set;}

        // Guarda o projeto onde a tarefa acima será realizada.
        // Inicializado como vazio.
        cProjeto projeto_atual {get; set;}
    }

    static class Financeiro
    {
        public struct tTransacao
        {
            String motivo;
            int valor;
            int data_da_ocorrencia;
        }

        public static List<tTransacao> transacao {
            get { return Financeiro.transacao; }
        }
        public static void setTransacao(tTransacao transacao) { throw new NotImplementedException(); }
    }

    static class Jogador
    {
        public static String nome { get; set; }
        public static String nome_empresa { get; set; }

        // O array de investidores tem 3 posições.
        // Cada posição é true se o investidor tiver sido escolhido e false caso contrário.
        public static bool[] investidores { get; set; }

        // Os valores iniciais das variáveis abaixo devem ser decididos posteriormente.
        public static int dinheiro { get; set; }
        public static int reputacao { get; set; }

        // O array de projetos ativos tem tamanho 3.
        // Eles devem ser inicializados como `null`
        private static cProjeto[] projetos_ativos;
        public static cProjeto getProjeto(int i) { throw new NotImplementedException(); }
        public static void setProjeto(cProjeto projeto, int i) { throw new NotImplementedException(); }

        // O array de funcionarios ativos tem tamanho 6.
        // Eles devem ser inicializados como `null`
        private static cFuncionario[] funcionarios;
        public static cFuncionario getFuncionario(int i) { throw new NotImplementedException(); }
        public static void setFuncionario(cFuncionario funcionario, int i) { throw new NotImplementedException(); }

        // O get e set abaixo recebem `i` que é um indice com base na posição
        // do projeto no array `projetos_ativos` e não no ID do projeto!
        public static cProjeto getProjeto_ativo(int i) { throw new NotImplementedException(); }
        public static void setProjeto_ativo(cProjeto projeto, int i) { throw new NotImplementedException(); }

    }

    static class Controle
    {
        /* Chama a função tarefa.completa_tarefa(int data)
         * Atualiza a qualidade_acumulada do projeto, e a qualidade_acumulada
         * das outras tarefas do projeto com base nas tabelas:
         * `ambiente.mTarefaTarefa` e `ambiente.mTarefaItem`
         * Também leva em consideração os bonus do Funcionário.
         *
         * Retorna erro se:
         * O funcionário não tiver o cargo necessário para realizar a tarefa
         * (verifique isso na tabela `ambiente.mCargoTarefa`, ou se
         * Algum pre-requisito da tarefa não tiver sido completado.
         * Verifique isso na tabela: `ambiente.mTarefaTarefa`
         *
         * A função também deve verificar se o projeto está completo.
         * Caso afirmativo deve marca-lo como completo e providenciar os bonus ao jogador na classe `jogador`
         */
        public static void completar_tarefa(cTarefa tarefa, cProjeto projeto, cFuncionario funcionario)
        {
            throw new NotImplementedException();
        }

        /*
         * Escolhe dentre os projetos definidos em `ambiente.getProjeto(i)`
         * deve escolher um de forma aleatória.
         *
         * Algumas restrições precisam ser evitadas, envolvendo a reputação e os investidores.
         * <Nota Garcia> Temos de discutir que restrições são essas. Ainda não sabemos. </Nota>
         */
        public static cProjeto sorteia_projeto(int reputacao, bool[] investidores)
        {
            throw new NotImplementedException();
        }

        /*
         * Gera um funcionários escolhidos de forma aleatória
         * dentre os funcionários disponíveis em `ambiente.getFuncionario(i)`
         *
         */
        public static cFuncionario processo_seletivo()
        {
            throw new NotImplementedException();
        }

        // Os logs abaixo devem ser auto-explicativos.
        // Precisam imprimir uma linha explicando o acontecimento no arquivo "log.txt" <sujeito a debate>
        public static void Log_realizou_tarefa(cTarefa tarefa, int data) { throw new NotImplementedException(); }
        public static void Log_contratou_funcionario(cFuncionario funcionario, int data) { throw new NotImplementedException(); }
        public static void Log_demitiu_funcionario(cFuncionario funcionario, int data) { throw new NotImplementedException(); }
        public static void Log_aceitou_projeto(cProjeto projeto, int data) { throw new NotImplementedException(); }
        public static void Log_completou_projeto(cProjeto projeto, int data) { throw new NotImplementedException(); } // (falhou ou não, mas completou)
        public static void Log_encerrou_turno(int data) { throw new NotImplementedException(); }
        public static void Log_terminou_jogo(int data) { throw new NotImplementedException(); } // (venceu ou perdeu)

    }

    public static class Ambiente
    {
        // Guarda o turno atual do jogo.
        public static int date {get; set;}

        // A enumeracao abaixo contém os nomes que diferenciam as areas de atuação na engenharia de software.
        // A enumeracao está incompleta, porque só lembrei de 3 nomes, é preciso preencher o resto.
        public enum eCategoria { Requisitos, Analise, Desenho, Implementacao, Teste, Gestão };

        // As matrizes abaixo já estão inicializadas, editem os valores para a matriz correta.
        // Quem for editar pode apagar a inicialização e fazer de forma manual dentro da construtora se preferir.
        public static List<List<int>> mTarefaTarefa;
        public static List<List<int>> mCargoTarefa;
        public static List<List<int>> mTarefaItem;

        public static void preencheMatrizTarefaTarefa(string caminhoArquivo)
        {
            try
            {
                mTarefaTarefa = new List<List<int>>();
                int indice = 0;

                using (StreamReader sr = new StreamReader(caminhoArquivo))
                {
                    string line = sr.ReadLine();
                    string[] split = line.Split(new Char[] { ' ' });

                    // Cria uma nova lista de tarefa
                    mTarefaTarefa[indice] = new List<int>();

                    int auxIndice = 0;

                    for (int i = 0; i < split.Count(); i++)
                    {
                        mTarefaTarefa[indice][i] = Convert.ToInt32(split[auxIndice]);
                    }

                    indice++;
                }
            }
            catch (DirectoryNotFoundException ex)
            {
                Console.WriteLine("Arquivo não encontrado em : " + caminhoArquivo);
            }
        }

        // Retorna a posição (i,j) da matriz mTarefaTarefa
        public static int getTarefaTarefa(int i, int j){
            throw new NotImplementedException();
        }

        // Retorna a posição (i,j) da matriz mCargoTarefa
        public static int getCargoTarefa(int i, int j){
            throw new NotImplementedException();
        }

        // Retorna a posição (i,j) da matriz mTarefaItem
        public static int getTarefaItem(int i, int j){
            throw new NotImplementedException();
        }

        // Esse array precisa ser inicializado na construtora.
        // Segundo a descrição do jesus ele conterá os projetos que criamos manualmente.
        // Note que o indice do projeto nesse array e o ID do projeto são identicos nesse array.
        private static readonly cProjeto[] projeto;
        public static cProjeto getProjeto(int i){
            throw new NotImplementedException();
        }

        // Esse array precisa ser inicializado na construtora.
        // Segundo a descrição do jesus ele conterá os funcionarios que criamos manualmente.
        // Note que o indice do funcionario nesse array e o ID do funcionario são identicos nesse array.
        public static cFuncionario[] funcionario;
        public static cFuncionario getFuncionario(int i){
            throw new NotImplementedException();
        }
        // Esse array precisa ser inicializado na construtora.
        // Esse array conterá as tarefas que especificamos previamente, com nome, categoria e indice.
        // Note que o indice da tarefa nesse array e o ID da tarefa são identicos nesse array.
        private static readonly cTarefa[] tarefa;
        public static cTarefa getTarefa(int i){
            throw new NotImplementedException();
        }

        // O dicionário abaixo precisa ser preenchido com os pares:
        // <nome do funcionário>, <indice do funcionário no array "this.funcionario">
        // O preenchimento deve ocorrer dentro da construtora.
        private static readonly Dictionary<String, int> nomesFuncionarios = new Dictionary<String, int>();
        public static int getIDFuncionario(String nome){
            throw new NotImplementedException();
        }

        // Inicializa a matriz mTarefaTarefa com os valores corretos.


    }

/*
 *  Exemplo de uso de um dicionario:
 *
 *  // Biblioteca necessária para usar o Dictionary:
 *  using System.Collections.Generic;
 *
 *  Dictionary<string, int> dictionary = new Dictionary<string, int>();
 *  dictionary.Add("cat"   ,  2);
 *  dictionary.Add("dog"   ,  1);
 *  dictionary.Add("llama" ,  0);
 *  dictionary.Add("iguana", -1);
 *
 *  // Para acessar o terceiro valor digito:
 *  ID_llama = dictionary["llama"];
 */

/*
 * Inicializando uma Classe junto com suas variáveis com os get's e set's colocados corretamente:
 *
 * class Thing {
 *     public string Prop1 {get; set; }
 *     public string Prop2 {get; set; }
 *     public string Prop3 {get; set; }
 *     public int    Prop4 {get; set; }
 * }
 *
 * Thing t = new Thing() { Prop1 = "expensive", Prop2 = "costly", Prop3 = "pricy", Prop4 = 0};
 *
 */