using Microsoft.AspNetCore.Authentication;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.Logging;
using System.Security.Claims;

namespace zero.Context;

public class ZeroContext : IZeroContext
{
  /// <inheritdoc />
  public Application Application { get; protected set; }

  /// <inheritdoc />
  public string AppId { get; protected set; }

  /// <inheritdoc />
  public ClaimsPrincipal BackofficeUser { get; protected set; }

  /// <inheritdoc />
  public bool IsBackofficeRequest { get; protected set; }

  /// <inheritdoc />
  public bool IsLoggedIntoBackoffice { get; protected set; }

  /// <inheritdoc />
  public IZeroOptions Options { get; protected set; }

  /// <inheritdoc />
  public Route Route => ResolvedRoute?.Route;

  /// <inheritdoc />
  public IRouteModel ResolvedRoute => HttpContextAccessor?.HttpContext?.Features.Get<IRouteModel>();

  /// <inheritdoc />
  public IZeroStore Store { get; private set; }

  /// <inheritdoc />
  public IServiceProvider Services { get; private set; }


  protected IApplicationResolver AppResolver { get; private set; }

  protected ICultureResolver CultureResolver { get; private set; }

  protected ILogger<ZeroContext> Logger { get; private set; }

  protected IHandlerHolder Handler { get; private set; }

  protected IHttpContextAccessor HttpContextAccessor { get; private set; }

  protected IPrimitiveTypeCollection ValueCollection { get; private set; }


  bool _resolved = false;


  public ZeroContext(IZeroOptions options, IHttpContextAccessor httpContextAccessor, IApplicationResolver appResolver, ICultureResolver cultureResolver, 
    ILogger<ZeroContext> logger, IZeroStore store, IHandlerHolder handler, IServiceProvider services)
  {
    Options = options;
    AppResolver = appResolver;
    CultureResolver = cultureResolver;
    Logger = logger;
    Store = store;
    Handler = handler;
    ValueCollection = new PrimitiveTypeCollection();
    HttpContextAccessor = httpContextAccessor;
    Services = services;
  }


  /// <inheritdoc />
  public async virtual Task Resolve(HttpContext context)
  {
    if (_resolved)
    {
      return;
    }

    if (context?.Request is null)
    {
      Store.ResolvedDatabase = null;
      return;
    }

    //if (!Options.SetupCompleted)
    //{
    //  return;
    //} // TODO setup

    _resolved = true;

    // check if the current request is a backoffice request
    IsBackofficeRequest = context.IsBackofficeRequest(Options.ZeroPath);

    // get the currently logged-in backoffice user
    BackofficeUser = new ClaimsPrincipal();
    IsLoggedIntoBackoffice = false;
    AuthenticateResult authResult = await context.AuthenticateAsync(Constants.Auth.BackofficeScheme);
    if (authResult?.Principal is not null)
    {
      BackofficeUser = authResult.Principal;
      IsLoggedIntoBackoffice = true;
    }

    // resolve current application
    Application = await AppResolver.Resolve(context, BackofficeUser);
    AppId = Application.Id;

    // set default database for document store
    Store.ResolvedDatabase = Application.Database;

    // set current culture
    await CultureResolver.Resolve(this);
  }


  /// <inheritdoc />
  public void Override(Application app)
  {
    Application = app;
    AppId = app?.Id;
    Store.ResolvedDatabase = app?.Database;
  }


  /// <inheritdoc />
  public ZeroContextScope CreateScope(Application app)
  {
    return new(this, app, Application);
  }


  /// <inheritdoc />
  public T Get<T>() => ValueCollection.Get<T>();


  /// <inheritdoc />
  public void Set<T>(T value) => ValueCollection.Set(value);


  /// <inheritdoc />
  public void Remove<T>() => ValueCollection.Remove<T>();
}



public class ZeroContextScope : IDisposable
{
  public IZeroContext Context { get; }

  public Application App { get; set; }

  public string Database { get; set; }

  public IZeroStore Store { get; set; }

  readonly Application _originalApp = null;


  internal ZeroContextScope(IZeroContext context, Application app, Application originalApp)
  {
    Context = context;
    App = app;
    Database = app.Database;
    Store = context.Store;
    _originalApp = originalApp;
    Context.Override(app);
  }

  /// <inheritdoc />
  public void Dispose()
  {
    Context.Override(_originalApp);
  }
}



public interface IZeroContext
{
  /// <summary>
  /// Currently loaded application
  /// </summary>
  Application Application { get; }

  /// <summary>
  /// Current loaded application Id
  /// </summary>
  string AppId { get; }

  /// <summary>
  /// Resolved backoffice user principal
  /// </summary>
  ClaimsPrincipal BackofficeUser { get; }

  /// <summary>
  /// Whether the current request is a backoffice request or not
  /// </summary>
  bool IsBackofficeRequest { get; }

  /// <summary>
  /// Whether the user is logged into the backoffice
  /// </summary>
  bool IsLoggedIntoBackoffice { get; }

  /// <summary>
  /// Global zero options
  /// </summary>
  IZeroOptions Options { get; }

  /// <summary>
  /// Document store
  /// </summary>
  IZeroStore Store { get; }

  /// <summary>
  /// Service container
  /// </summary>
  IServiceProvider Services { get; }

  /// <summary>
  /// Matching (frontend) path route
  /// </summary>
  Route Route { get; }

  /// <summary>
  /// Matching (frontend) resolved route
  /// </summary>
  IRouteModel ResolvedRoute { get; }

  /// <summary>
  /// Resolves the current application (for backoffice + frontend requests) and
  /// the currently active backoffice user, as users are not signed in with the default scheme and do therefore not populate HttpContext.User
  /// </summary>
  Task Resolve(HttpContext context);

  /// <summary>
  /// Overrides the resolved application for this context instance
  /// </summary>
  void Override(Application app);

  /// <summary>
  /// SCOPE
  /// </summary>
  ZeroContextScope CreateScope(Application app);

  /// <summary>
  /// Get a custom property from this scoped context
  /// </summary>
  T Get<T>();

  /// <summary>
  /// Add a custom property to this scoped context
  /// </summary>
  void Set<T>(T value);

  /// <summary>
  /// Remove a custom property from this scoped context
  /// </summary>
  void Remove<T>();
}