// GET: Locacao
        public ActionResult Index(int id)
        {
            var jogo = repositorio.BuscarPorId(id);
            Locacao locacao = new Locacao(jogo);
            LocacaoModel model = new LocacaoModel(locacao);

            return View(model);
        }
 public ActionResult Locacao(int id)
 {
     LocacaoModel locacao = new LocacaoModel();
     locacao.Jogo = acessoBDJogo.BuscarPorId(id);
     //TODO: Refatorar a lógica dos métodos abaixo
     locacao.DataDevolucao = locacao.CalculoDeDias(locacao.Jogo);
     locacao.PrecoLocacao = locacao.ValorLocacao(locacao.Jogo);
     return View(locacao);
 }
        public ActionResult Salvar(LocacaoModel model)
        {
            LocacaoRepositorio repLocacao = new LocacaoRepositorio();
            Jogo jogo = new JogoRepositorio().BuscarPorId(model.IdJogo);
            Cliente cliente = new ClienteRepositorio().BuscarPorId(model.IdClient);
            Locacao Locacao = new Locacao(jogo, cliente, model.DataLocacao);

            repLocacao.Criar(Locacao);

            return RedirectToAction("JogosDisponiveis", "Relatorio");
        }
        public ActionResult DevolverJogo(LocacaoModel locacao)
        {
            var diasAtraso = DateTime.Now.Day - locacao.DataPrevista.Day;
            var juros = diasAtraso * 5;

            if (diasAtraso > 0)
            {
                locacao.Valor += diasAtraso;
            }

            return View(locacao);
        }
        public ActionResult Locacao(int id)
        {
            var jogo = new JogoRepositorio().BuscarPorId(id);

            var model = new LocacaoModel();
            model.Jogo = jogo;
            model.IdJogo = jogo.Id;
            model.DataLocacao = DateTime.Now;
            model.DataPrevistaEntrega = model.DataLocacao.AddDays(jogo.Selo.Prazo);
            model.ValorInicial = jogo.Selo.Preco;

            return View(model);
        }
        public ActionResult Salvar(LocacaoModel model)
        {
            jogoRepositorio = FabricaDeModulos.CriarJogoRepositorio();
            clienteRepositorio = FabricaDeModulos.CriarClienteRepositorio();
            locacaoRepositorio = FabricaDeModulos.CriarLocacaoRepositorio();

            servicoLocacao = new ServicoLocacao(jogoRepositorio, clienteRepositorio, locacaoRepositorio);

            bool locacaoEfetuadaComSucesso = servicoLocacao.LocarJogoParaCliente(model.IdJogo, model.NomeCliente);

            @TempData["Mensagem"] = locacaoEfetuadaComSucesso ? "Locação efetuada" : "Erro na locação";
            @TempData["TipoMensagem"] = locacaoEfetuadaComSucesso ? "sucesso" : "falha";

            return RedirectToAction("JogosDisponiveis", "Relatorio");
        }
        public ActionResult Devolver(LocacaoModel model)
        {
            if (ModelState.IsValid)
            {
                var repositorio = FabricaDeModulos.CriarLocacaoRepositorio();
                var locacao = repositorio
                                .BuscarPorId(repositorio
                                .BuscarIdPorIdJogo(FabricaDeModulos.CriarJogoRepositorio()
                                .BuscarPorNome(model.NomeJogo)[0].Id));

                locacao.DataDevolucao = DateTime.Now;
                repositorio.Atualizar(locacao);
                //return View(LocacaoParaLocacaoModel(locacao));
            }
            return View("IndexDevolucao");
        }
        public ActionResult SalvarLocacao(LocacaoModel locacaoModel)
        {
            Cliente clienteLocador = acessoBDCliente.BuscarPorId(locacaoModel.IdCliente);
            var locacoes = acessoBDLocacao.BuscarLocacoesPorCliente(clienteLocador.Id);
            var quantidade = locacoes.Count;
            var podeLocar = locacaoModel.ClientePodeLocar(quantidade);
            if (ModelState.IsValid && podeLocar)
            {
                Locacao locacao = new Locacao(clienteLocador.Id, locacaoModel.Jogo.Id, locacaoModel.DataDevolucao, locacaoModel.PrecoLocacao);
                acessoBDLocacao.Locacao(locacao);
                ViewBag.Locado = "Jogo locado com sucesso";
                return View();
            }

            return RedirectToAction("Locacao", "Locacao", locacaoModel);

        }
        private void CriarListaLocacaoModel(IList<Locacao> lista)
        {
            foreach (var locacao in lista)
            {
                var model = new LocacaoModel()
                {
                    IdLocacao = locacao.Id,
                    Valor = locacao.Valor,
                    NomeJogo = locacao.Jogo.Nome,
                    NomeCliente = locacao.Cliente.Nome,
                    DataPrevista = locacao.DataParaDevolucao,
                    DataEntrega = locacao.DataDevolucao,
                    Status = locacao.Status.ToString()
                };

                this.Locacoes.Add(model);
            }
        }
        public ActionResult PaginaDevolucao(int? id)
        {
            if (id.HasValue)
            {
                ServicoLocacaoRepositorio locacaoRepositorio = new ServicoLocacaoRepositorio();

                ServicoLocacao locacao = locacaoRepositorio.PesquisarPorJogo((int)id);

                int idParameter = (int)id;

                if (locacao == null)
                {
                    return RedirectToAction("PaginaLocacao", "Locacao", new { id = idParameter });
                }

                LocacaoModel model = new LocacaoModel(locacao);

                return View(model);
            }

            return RedirectToAction("BuscaDevolucao");
        }
        public ActionResult Locar(LocacaoModel model)
        {
            if (ModelState.IsValid)
            {
                var cliente = FabricaDeModulos.CriarClienteRepositorio()
                                .BuscarPorNome(model.NomeCliente).FirstOrDefault();
                var jogo = FabricaDeModulos.CriarJogoRepositorio()
                            .BuscarPorId(model.IdJogo);

                var locacao = new Locacao(jogo, cliente);

                var repositorio = FabricaDeModulos.CriarLocacaoRepositorio();
                IServicoLocacao servico = new ServicoLocacao(repositorio);

                if (servico.VerificarDisponibilidade(jogo.Id))
                {
                    repositorio.Criar(locacao);
                }

                return RedirectToAction("JogosDisponiveis", "Relatorio");
            }
            return View("Index", model.IdJogo);
        }
        public ActionResult Locacao(int id)
        {
            jogoRepositorio = FabricaDeModulos.CriarJogoRepositorio();

            var jogo = jogoRepositorio.BuscarPorId(id);
            bool jogoNaoEncontrado = jogo == null;

            if (jogoNaoEncontrado)
            {
                RedirectToAction("JogosDisponiveis", "Relatorio");
            }

            var model = new LocacaoModel()
            {
                IdJogo = jogo.Id,
                NomeJogo = jogo.Nome,
                ImagemJogo = jogo.Imagem,
                NomeSelo = jogo.Selo.Nome,
                Valor = jogo.Selo.Preco,
                DataPrevista = DateTime.Now.AddDays(jogo.Selo.PrazoDevolucao)
            };

            return View(model);
        }
        private Locacao LocacaoModelParaLocacao(LocacaoModel model)
        {
            var jogo = new Jogo(model.IdJogo)
            {
                Nome = model.NomeJogo,
                Categoria = (Categoria)Enum.Parse(typeof(Categoria), model.Categoria),
                Selo = (Selo)Enum.Parse(typeof(Selo), model.Selo),
                Descricao = model.Descricao,
                UrlImagem = model.UrlImagem,
                TagVideo = model.TagVideo
            };

            var cliente = new Cliente(model.IdCliente) { Nome = model.NomeCliente };

            return new Locacao(jogo, cliente);
        }
        public ActionResult LocarJogo(int? id)
        {
            var jogoRepositorio = ModuleBuilder.CriarJogoRepositorio();

            if(!id.HasValue)
            {
                TempData["Mensagem"] = "Ocorreu um erro!";
                return RedirectToAction("JogosDisponiveis", "RelatorioJogo");
            }

            var jogo = jogoRepositorio.BuscarPorId(id.Value);

            if (jogo == null)
            {
                TempData["Mensagem"] = "Ocorreu um erro!";
                return RedirectToAction("JogosDisponiveis", "RelatorioJogo");
            }

            var model = new LocacaoModel()
            {
                IdJogo = id.Value,
                ImagemJogo = jogo.Imagem,
                Selo = jogo.Selo.ToString(),
                NomeJogo = jogo.Nome,
            };

            model.Valor = model.GetValor();
            model.DataPrevista = model.GetDataPrevista();

            return View(model);
        }
 private Jogo LocacaoModelParaJogo(LocacaoModel model)
 {
     return new Jogo(model.IdJogo)
     {
         Nome = model.NomeJogo,
         Selo = (Selo)Enum.Parse(typeof(Selo), model.Selo),
         Categoria = (Categoria)Enum.Parse(typeof(Categoria), model.Categoria),
         Descricao = model.Descricao,
         UrlImagem = model.UrlImagem,
         TagVideo = model.TagVideo
     };
 }
        public ActionResult ServicoDevolucao(LocacaoModel model)
        {
            if (model.IdLocacao.HasValue)
            {
                var servico = ModuleBuilder.CriarServicoLocacao();

                servico.DevolverJogo(model.IdLocacao.Value);

                TempData["Mensagem"] = "Jogo devolvido com sucesso";
                return RedirectToAction("Index", "Locar");
            }

            TempData["Mensagem"] = "Ocorreu um erro!";
            return RedirectToAction("Index", "Locar");
        }
        public ActionResult Salvar(LocacaoModel model)
        {
            if (ModelState.IsValid)
            {
                var clienteRepositorio = ModuleBuilder.CriarClienteRepositorio();
                var locacaoRepositorio = ModuleBuilder.CriarLocacaoRepositorio();
                var cliente = clienteRepositorio.BuscarPorIdPorNome(model.NomeCliente);
                var servico = ModuleBuilder.CriarServicoLocacao();

                if (cliente == null)
                {
                    TempData["Mensagem"] = "Cliente não encontrado!";
                    return RedirectToAction("JogosDisponiveis", "RelatorioJogo");
                }

                var numeroDeJogosCliente = locacaoRepositorio.GetCountJogosDoCliente(cliente.Id);
                if (numeroDeJogosCliente >= 3)
                {
                    TempData["Mensagem"] = "Cliente possui o limite de locações!";
                    return RedirectToAction("JogosDisponiveis", "RelatorioJogo");
                }

                servico.LocarJogo(model.IdJogo, cliente.Id);

                TempData["Mensagem"] = "Jogo locado com sucesso!";
                return RedirectToAction("JogosDisponiveis", "RelatorioJogo");
            }

            ModelState.AddModelError("", "Ocorreu um erro!");
            return RedirectToAction("LocarJogo", "Locar", model.IdJogo);
        }