/*
BLOCO A

a) Compila certinho e vai aparecer 4 e 2
b) Nao compila, ja que o n e privado e ele nao pode ser alterado fora da classe
c) A primeira parte compila certinho e resultaria em 2 mas a segunda parte 
   da errado ja que como no anterior ele tenta mudar um parametro privado

class Contador {
 private _n = 0;
    
 incrementar(): void {
     this._n++;
 }
    
 get n(): number {
     return this._n;
 }
}

function duas(c: Contador): void {
 c.incrementar();
 c.incrementar();
}

const x = new Contador();
const y = new Contador();

duas(x);
duas(x);
duas(y);
console.log(x.n, y.n);

const c = new Contador(5);
console.log(c.n);

const c = new Contador();
c.incrementar();
c.n = 10;
console.log(c.n);

4.d) Comeca dando certo ate tentar colocar [] nos itens, e depois tentar ver o
     tamanho que fica.

class Caixa {
    readonly itens: number[] = [];
}

const c = new Caixa();

c.itens.push(7);
c.itens.push(9);
console.log(c.itens.length);

c.itens = [];
console.log(c.itens.length);

5.e) Nao da certo ja que so entra o valor 10 e ele fica no espaço 0, no 1 nao
     tem o que mostrar, ai da erro.

class Historico {
 private _valores: number[] = [];
    
 registrar(v: number): boolean {
     if (v < 0) return false;
     this._valores.push(v);
     return true;
 }
    
 get valores(): number[] {
     return this._valores;
 }
    
 get quantidade(): number {
     return this._valores.length;
 }
    
}

const h = new Historico();

h.registrar(10);
h.registrar(-4);
h.valores.push(-99);
console.log(h.quantidade, h.valores[1]);

6.f) Nao compila, o constructor esta errado, fora que ele nao explicita que alvo
     e um valor numerico

class Termostato {
 private _alvo = 20;
    
 constructor(readonly local: string) {}
    
 get alvo(): number {
     return this._alvo;
 }
    
 definirAlvo(a: number): boolean {
     if (a < 5 || a > 30) return false;
     this._alvo = a;
     return true;
 }
    
}

const t = new Termostato("Sala");

console.log(t.definirAlvo(35));
console.log(t.definirAlvo(30), t.alvo);
console.log(t.definirAlvo(4), t.alvo);

const u = t;
u.definirAlvo(5);
console.log(t.alvo, t.local === u.local);


BLOCO B 
  ______________ tem 1____________tem 1 ___________
7.| VoluntResp | <-- | Canteiro | --> |   Horta  | 
  |------------|     |----------|     |----------|
  |    nome    |     |voluntResp|     |   nome   |
  |  telefone  |     |histColhei|     |canteiros |
                           ^
                           | tem 1 canteiro
                      ____________     
                      | Colheita |
                      |----------|
                      |   data   |
                      |  quilos  |
Os canteiros tem uma relacao de composicao com a Horta, ja que
se a horta nao existisse nao existiriam canteiros;
os canteiros tem uma relacao de composicao com a colheita, ja que 
se nao tiverem canteiros nao terao colheitas
os canteiros tem uma relacao de associacao com os voluntarios responsaveis
isso porque sem o canteiro o voluntario responsavel continua existindo.


8) A classe RelatorioMensal acumula muitas funcoes; pra dividir melhor podemos:
   fazer uma classe leitorDados para fornescer os dados brutos;
   a classe calculadoraMedia pra fazer os calculos dos dados;
   a classe formatadorRelatorio para formatar o documento para 
   exibicao; e a classe enviarEmail que apenas gerencia o envio 
   dos emails; mesmo assim as partes dependem uma das outras
9.a) inserir com o que esta chegando sendo um void -> adiciona ao final
     da fila
     remover no caso quem esta no comeco da fila -> remove o elemento e 
     entrega a fila nova
     primeiro com o elemento do inicio da fila -> consulta quem e o proximo
     vazia analisa se esta ou nao com elementos
     tamanho volta o tamanho da lista
  b) Os elemntos na fila se mantem ordenados da forma primeiro a entrar, 
     primeiro a sair, comportamento LIFO
  c) Pode ser representada por um vetor dinamico ou mesmo uma lista encadeada que 
     guarda os ponteiros do inicio e do final (nunca podem ser iguais, se nao ta 
     vazia). As pessoas nao deveriam ver isso por conta da seguranca do codigo


BLOCO C

10)

class Termostato {
    private _alvo = 20;

    constructor(readonly local: string) {}

    definirAlvo(a: number): boolean {
        if(a < 5 || a > 30) {
            return false;
        } this._alvo = a;
        return true;
    }

    get alvo(): number {
        return this._alvo;
    }

    precisaAquecer(atual: number): boolean {
        if(atual < this.alvo) {
            return true;
        }return false;
    }
}

const t = new Termostato("Sala");
console.log(t.alvo, t.precisaAquecer(19), t.precisaAquecer(20));
console.log(t.definirAlvo(30), t.definirAlvo(31), t.definirAlvo(5),
t.definirAlvo(4.9));
console.log(t.alvo, t.precisaAquecer(10));

11)

class Canteiro {
   constructor(readonly numero: number; readonly area: number) {}
}

class Horta {
    private canteiros = Canteiro[] = [];

    buscar(numero: number): Canteiro | undefined {
        return this.canteiros.find(c => c.numero === numero);
    }

    adicionar(c: Canteiro): boolean {
        if(this.buscar(c.numero) !== undefined) {
            return false;
        }
        this.canteiros.push(c);
        return true;
    }

    areaTotal(): number {
        return this.canteiros.reduce((total,c) ==> total + c.area, 0);
    }
}

const h = new Horta();
console.log(h.adicionar(new Canteiro(1, 12.5)), h.adicionar(new Canteiro(2, 8)),
h.adicionar(new Canteiro(1, 30)));
console.log(h.areaTotal(), h.buscar(2)?.area, h.buscar(3));

12)

class Sensor {
 private leituras: number[] = [];
    
 constructor(readonly unidade: string, readonly minimo: number, readonly maximo:
number) {}
    
 aceita(x: number): boolean {
     return x >= this.minimo && x <= this.maximo;
 }
    
 registrar(x: number): boolean {
     if (!this.aceita(x)) return false;
     this.leituras.push(x);
     return true;
 }
    
 get quantidade(): number {
     return this.leituras.length;
 }
}

class ModuloDHT22 {
    private sensorTemp: Sensor = new Sensor("°C", -40, 80);
    private sensorUmid: Sensor = new Sensor("%", 0, 100);
    private paresGuardados: number = 0;

    constructor(readonly local: string) {}

    registrarPar(t: number, u:number): boolean {
        if(!this.sensorTemp.aceita(t) || !this.sensorUmid.aceita(u)) {
            return false;
        }
        this.sensorTemp.registrar(t);
        this.sensorUmid.registrar(u);
        this.paresGuardados++;
        return true;
    }

    get quantidade(): number {
        return this.paresGuardados;
    }
}

const m = new ModuloDHT22("Sul");
console.log(m.registrarPar(25, 60), m.registrarPar(90, 50), m.registrarPar(20,
120), m.registrarPar(-40, 100));
console.log(m.quantidade);

Se o primeiro fosse valido e o segundo invalido, o primeiro salvaria e o segundo nao
   isso nao funciona com o negocio do "tudo ou nada", parte dos dados seria perdida assim.
*/