using System.Linq;
using System.Security.Claims;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using isnd.Data;
using isnd.ViewModels;
using isnd.Helpers;
using isnd.Interfaces;

namespace isnd
{
    [AllowAnonymous]
    public class PackageVersionController : Controller
    {
        private readonly ApplicationDbContext _context;
        private readonly IPackageManager _pm;

        public PackageVersionController(ApplicationDbContext context,
            IPackageManager pm)
        {
            _context = context;
            _pm = pm;
        }

        // GET: PackageVersion
        public async Task<IActionResult> Index(PackageVersionIndexViewModel model)
        {
            var applicationDbContext = _context.PackageVersions.Include(p => p.Package).Where(
                p => (model.Prerelease || !p.IsPrerelease)
            && ((model.PackageId == null) || p.PackageId.StartsWith(model.PackageId)));
            model.Versions = await applicationDbContext.ToArrayAsync();
            return View(model);
        }

        [Authorize]
        public async Task<IActionResult> Mines(PackageVersionIndexViewModel model)
        {
            var userId = User.FindFirstValue(ClaimTypes.NameIdentifier);
            var applicationDbContext = _context.PackageVersions
                .Include(p => p.Package).Where(
                p => (string.IsNullOrEmpty(model.PackageId) || p.PackageId.StartsWith(model.PackageId))
                && p.Package.OwnerId == userId);

            model.Versions = await applicationDbContext.ToArrayAsync();

            return View("Index", model);
        }

        // GET: PackageVersion/Details/5
        public async Task<IActionResult> Details(string pkgid, string version)
        {
            if (pkgid == null || version == null)
            {
                return NotFound();
            }

            var packageVersion = await _context.PackageVersions
                .Include(p => p.Package)
                .FirstOrDefaultAsync(m => m.PackageId == pkgid && m.FullString == version);
            if (packageVersion == null)
            {
                return NotFound();
            }

            return View(packageVersion);
        }

        [Authorize]
        public async Task<IActionResult> Delete(string pkgid, string version, string pkgtype)
        {
            if (pkgid == null || version == null)
            {
                return NotFound();
            }

            var packageVersion = await _context.PackageVersions.Include(p => p.Package)
             .FirstOrDefaultAsync(m => m.PackageId == pkgid
             && m.FullString == version && m.Type == pkgtype);
            if (packageVersion == null) return NotFound();
            if (!User.IsOwner(packageVersion)) return Unauthorized();
            var pkg = await _pm.GetPackageAsync(pkgid, version, pkgtype);
            return View(pkg);
        }


        // POST: PackageVersion/Delete/5
        [HttpPost, ActionName("Delete")]
        [ValidateAntiForgeryToken]
        public async Task<IActionResult> DeleteConfirmed(string PackageId, string FullString,
         string Type)
        {
            PackageVersion packageVersion = await _context.PackageVersions.Include(p => p.Package)
             .FirstOrDefaultAsync(m => m.PackageId == PackageId
             && m.FullString == FullString && m.Type == Type);
            if (packageVersion == null) return NotFound();
            if (!User.IsOwner(packageVersion)) return Unauthorized();

            await _pm.DeletePackageAsync(PackageId, FullString, Type);
            return RedirectToAction(nameof(Index));
        }


    }
}
