using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using isn.abst;
using isnd.Data;
using isnd.Data.Catalog;
using isnd.Entities;
using isnd.Helpers;
using isnd.ViewModels;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Components.Web.Virtualization;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;

namespace isnd.Controllers
{

    public partial class PackagesController
    {
        // Web search
        public async Task<IActionResult> Index(PackageRegistrationQuery model)
        {
            var pkgs = await packageManager.SearchPackageAsync(model);
            var result = new RegistrationPageIndexQueryAndResult
            {
                Source = packageManager.CatalogBaseUrl+ApiConfig.Index,
                Query = model
            };
            List<Catalog> registrations = new List<Catalog>();
            if (pkgs.data!=null) 
            if (pkgs.data.Length>0)
            {
                var grouped = pkgs.data.GroupBy(x => x.PackageId);
                if (grouped!=null) if (grouped.Count()>0)
                {
                    foreach (var pk in grouped.ToArray())
                    {
                        registrations.Add(new Catalog(apiBase, pk.Key, pkgs.GetResults().Single(p=>p.Id == pk.Key).Versions)); 
                    }
                }
            }
           
            return View(new RegistrationPageIndexQueryAndResult
            {
                Source = packageManager.CatalogBaseUrl+ApiConfig.Index,
                Query = model,
                Result = registrations.ToArray()
            });
        }

        public async Task<IActionResult> Details(PackageDetailViewModel model)
        {
            if (model.pkgid == null)
            {
                return NotFound();
            }

            var packageVersion = dbContext.PackageVersions
             .Include(p=>p.LatestCommit)
                .Include(p => p.Package)
                .Where(m => m.PackageId == model.pkgid)
                .OrderByDescending(p => p)
                ;

            if (packageVersion.Count() == 0)
            {
                return NotFound();
            }
            bool results = await packageVersion.AnyAsync();
            model.latest = await packageVersion.FirstAsync();
            model.totalHits = packageVersion.Count();
            model.data = packageVersion.Take(MAX_PKG_VERSION_LIST).ToArray();

            return View("Details", model);
        }
        const int MAX_PKG_VERSION_LIST = 50;

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

            var packageVersion = await dbContext.PackageVersions.Include(p => p.Package)
             .FirstOrDefaultAsync(m => m.PackageId == pkgid && m.FullString == version 
             && (pkgtype!=null && m.Type == pkgtype || m.Type != "Delete" ));
            if (packageVersion == null) return NotFound();
            if (!User.IsOwner(packageVersion)) return Challenge();
            var pkg = await packageManager.GetPackageDetailsAsync(pkgid, version, pkgtype);
            return View(pkg);
        }

        // POST: PackageVersion/Delete/5
        [HttpPost]
        [ValidateAntiForgeryToken][Authorize]
        public async Task<IActionResult> DeleteConfirmed(string pkgid, string version,
         string type)
        {
            var packageVersion = await dbContext.PackageVersions
             .Include(pv => pv.Package)
             .Where(m => m.PackageId == pkgid
             && m.FullString == version && (type==null || m.Type == type))
             .ToArrayAsync();
            if (packageVersion.Length==0) return NotFound();
            if (!User.IsOwner(packageVersion.First())) return Unauthorized();
            await packageManager.DeletePackageAsync(pkgid, version, type);
            return RedirectToAction(nameof(Index));
        }
    }

}