using EnertechWebAPI.Data;
using EnertechWebAPI.Interfaces;
using EnertechWebAPI.Models;
using EnertechWebAPI.Responses;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;

namespace EnertechWebAPI.Controllers
{
    [Authorize]
    [Route("api/[controller]")]
    [ApiController]
    public class DashboardController : BaseApiController
    {
        private readonly DataContext _context;
        private readonly IDashboardService dashboardService;

        public DashboardController(DataContext context, IDashboardService dashboardService)
        {
            _context = context;
            this.dashboardService = dashboardService;
        }

        [HttpGet]
        public async Task<IActionResult> Get()
        {
            var getDashboardResponse = await dashboardService.GetDashboard(UserID);
            if (!getDashboardResponse.Success)
            {
                return UnprocessableEntity(getDashboardResponse);
            }
            var db = getDashboardResponse.Dashboard;
            var dashboardResponse = new DashboardResponse
            {
                dashId = db.dashId,
                BioMass = db.BioMass,
                CarbonBalance = db.CarbonBalance,
                Veterinary = db.Veterinary,
                Energy = db.Energy,
                Healthcare = db.Healthcare,
                Internet = db.Internet,
                paidEnergy = db.paidEnergy,
                paidHealthcare = db.paidHealthcare,
                paidInternet = db.paidInternet,
                paidVeterinary = db.paidVeterinary,
                Username = db.Username
            };

            //var dashboardResponse = getDashboardResponse.Dashboard.ConvertAll(o => new DashboardResponse
            //{
            //    dashId = o.dashId,
            //    BioMass = o.BioMass,
            //    CarbonBalance = o.CarbonBalance,
            //    Veterinary = o.Veterinary,
            //    Energy = o.Energy,
            //    Healthcare = o.Healthcare,
            //    Internet = o.Internet,
            //    paidEnergy = o.paidEnergy,
            //    paidHealthcare = o.paidHealthcare,
            //    paidInternet = o.paidInternet,
            //    paidVeterinary = o.paidVeterinary,
            //    Username = o.Username
            //});

            return Ok(dashboardResponse);
        }

        [HttpPut("{service}")]
        public async Task<IActionResult> Put(string service)
        {
            var putDashboardResponse = await dashboardService.PutDashboard(UserID, service);
            if (!putDashboardResponse.Success)
            {
                return UnprocessableEntity(putDashboardResponse);
            }
            return Ok(putDashboardResponse);
        }

        /*[HttpGet("{id}")]
        public async Task<ActionResult<List<Dashboard>>> GetDashboard(int id)
        {
            var dbUser = await _context.EnertechUsers.FindAsync(id);
            if (dbUser == null)
                return BadRequest("User Not Found.");

            return Ok(await _context.Dashboard.FindAsync(id));
        }

        [HttpPut("{amount}")]
        public ActionResult<double> AddCredits(EnertechUser user, int amount)
        {
            var dbUser = _context.EnertechUsers.Find(user.userId);
            if (dbUser == null)
                return BadRequest("User Not Found.");

            var dbDb = _context.Dashboard.FindAsync(user.Username);
            dbUser.Balance = user.Balance + amount;

            _context.SaveChanges();
            return Ok(dbUser.Balance);
        }

        [HttpPut("{id}/{service}")]
        public async Task<ActionResult<Dashboard>> UpdateService(int id, string service)
        {
            var dbUser = await _context.EnertechUsers.FindAsync(id);
            if (dbUser == null)
                return BadRequest("User Not Found.");

            var dbDb = await _context.Dashboard.FindAsync(dbUser.userId);
            var p = new Prices();

            if (service == "Energy")
            {
                dbUser.Balance = dbUser.Balance - p.EnergyPrice;
                dbDb.Energy = true;
                dbDb.paidEnergy = DateTime.Now;
            }

            if (service == "Internet")
            {
                dbUser.Balance = dbUser.Balance - p.InternetPrice;
                dbDb.Internet = true;
                dbDb.paidInternet = DateTime.Now;
            }

            if (service == "Healthcare")
            {
                dbUser.Balance = dbUser.Balance - p.HealthcareSub;
                dbDb.Healthcare = true;
                dbDb.paidHealthcare = DateTime.Now;
            }

            if (service == "Veterinary")
            {
                dbUser.Balance = dbUser.Balance - p.VeterinarySub;
                dbDb.Veterinary = true;
                dbDb.paidVeterinary = DateTime.Now;
            }

            if (service == "Carbon")
            {
                dbUser.Balance = dbUser.Balance + dbDb.CarbonBalance;
                dbDb.CarbonBalance = 0;
            }

            if (service == "Biomass")
            {
                dbUser.Balance = dbUser.Balance + dbDb.BioMass;
                dbDb.BioMass = 0;
            }

            await _context.SaveChangesAsync();
            return Ok(await _context.Dashboard.FindAsync(id));
        }

        [HttpGet]
        public async Task<ActionResult<List<Training>>> GetTraining()
        {
            return Ok(await _context.Training.ToListAsync());
        }

        [HttpPut("{id}/training/{trainingid}")]
        public async Task<ActionResult<Dashboard>> Training(int id, int trainingid)
        {
            var dbUser = await _context.EnertechUsers.FindAsync(id);
            if (dbUser == null)
                return BadRequest("User Not Found.");

            var dbUserTraining = await _context.UserTraining
                .FirstAsync(c => c.userId == dbUser.userId && c.TrainingId == trainingid);

            dbUserTraining.Completed = true;

            await _context.SaveChangesAsync();
            return Ok(await _context.Dashboard.FindAsync(id));
        }*/
    }
}