using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore.Query;
using Microsoft.Extensions.Logging;
using xCommons.Configurations;
using xCommons.Extensions;
using xCommons.Providers;
using xExceptions.Constants;
using xIdentityService.Controllers;
using xIdentityService.Interfaces;
using xModels.Base;
using xModels.Dtos;
using xPushService.Base;
using xPushService.Interfaces;

namespace xPushService.Controllers
{
    [AllowAnonymous]
    public abstract class XBaseProvidedController<TEntity, TDto, TKey, THub> : XBaseIdentityApiV1Controller, IXBaseProvidedController<TEntity, TDto, TKey, THub>
    where TEntity : XBaseEntity<TKey>
    where TDto : XBaseEntityDto<TKey>
    where THub : XBaseDtoHub<TEntity, TDto, TKey>
    {
        private readonly IXBaseProvided<TEntity, TDto, TKey, THub> provider;
        private readonly Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>> defaultOrderBuilder;
        private readonly Func<IQueryable<TEntity>, IIncludableQueryable<TEntity, object>> defaultIncludeBuilder;

        protected XBaseProvidedController(
            ILogger<XBaseProvidedController<TEntity, TDto, TKey, THub>> logger,
            XAppConfiguration appConfiguration,
            IXIdentityProvider identityProvider,
            XValidationProvider validationProvider,
            IXBaseProvided<TEntity, TDto, TKey, THub> provider,
            Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>> defaultOrderBuilder = null,
            Func<IQueryable<TEntity>, IIncludableQueryable<TEntity, object>> defaultIncludeBuilder = null
        ) : base(
            logger,
            appConfiguration,
            identityProvider,
            validationProvider
        )
        {
            this.provider = provider;
            this.defaultOrderBuilder = defaultOrderBuilder;
            this.defaultIncludeBuilder = defaultIncludeBuilder;
        }

        //
        #region Retrieve ...
        /// <summary>
        /// Get Specified Item by ID ...
        /// </summary>
        /// <param name="id"></param>
        /// <param name="useDefaultIncludes"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        [HttpGet("{id}")]
        public virtual async Task<ActionResult<TDto>> Get(
            [FromRoute] TKey id,
            [FromQuery] bool useDefaultIncludes = false,
            CancellationToken cancellationToken = default
        )
        {
            //
            try
            {
                //
                // Validate ...
                if (!ModelState.IsValid)
                {
                    XException.InvalidArgs.Throw();
                }
                ValidationProvider.NotNull(id);

                //
                var result = await provider.Get(
                    id: id,
                    includeBuilder: !useDefaultIncludes
                        ? null
                        : defaultIncludeBuilder,
                    cancellationToken: cancellationToken
                );

                //
                return Ok(result.ToDynamicObject());
            }
            catch (Exception ex)
            {
                //
                var result = GetExceptionActionResult(ex);
                return result;
            }
        }

        /// <summary>
        /// Get All Exists Items ...
        /// </summary>
        /// <param name="useDefaultOrders"></param>
        /// <param name="useDefaultIncludes"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        [HttpGet("")]
        public virtual async Task<ActionResult<IEnumerable<TDto>>> GetAll(
            [FromQuery] bool useDefaultOrders = false,
            [FromQuery] bool useDefaultIncludes = false,
            CancellationToken cancellationToken = default
        )
        {
            //
            try
            {
                //
                // Validate ...
                if (!ModelState.IsValid)
                {
                    XException.InvalidArgs.Throw();
                }

                //
                var result = await provider.GetAll(
                    orderBuilder: !useDefaultOrders
                        ? null
                        : defaultOrderBuilder,
                    includeBuilder: !useDefaultIncludes
                        ? null
                        : defaultIncludeBuilder,
                    cancellationToken: cancellationToken
                );

                //
                return Ok(result.ToDynamicObject());
            }
            catch (Exception ex)
            {
                //
                var result = GetExceptionActionResult(ex);
                return result;
            }
        }

        /// <summary>
        /// Find an item by providing a Conditional Expression ...
        /// </summary>
        /// <param name="query"></param>
        /// <param name="useDefaultIncludes"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        [HttpGet("Find/One")]
        public virtual async Task<ActionResult<TDto>> FindOne(
            [FromRoute] string query,
            [FromQuery] bool useDefaultIncludes = false,
            CancellationToken cancellationToken = default
        )
        {
            //
            try
            {
                //
                // Validate ...
                if (!ModelState.IsValid)
                {
                    XException.InvalidArgs.Throw();
                }
                await ValidationProvider
                    .GroupValidationBuilder()
                    .AddNotEmpty(query)
                    .ValidateGroupAsync();

                //
                var result = await provider.FindOne(
                    includeBuilder: !useDefaultIncludes
                        ? null
                        : defaultIncludeBuilder,
                    cancellationToken: cancellationToken,
                    predicate: x => x.PropValuesContains(query)
                );

                //
                return Ok(result.ToDynamicObject());
            }
            catch (Exception ex)
            {
                //
                var result = GetExceptionActionResult(ex);
                return result;
            }
        }

        /// <summary>
        /// Find a collection of Items by proving a Query Search ...
        /// </summary>
        /// <param name="query"></param>
        /// <param name="useDefaultOrders"></param>
        /// <param name="useDefaultIncludes"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        [HttpGet("Find/Many")]
        public virtual async Task<ActionResult<IEnumerable<TDto>>> FindMany(
            [FromRoute] string query,
            [FromQuery] bool useDefaultOrders = false,
            [FromQuery] bool useDefaultIncludes = false,
            CancellationToken cancellationToken = default
        )
        {
            //
            try
            {
                //
                // Validate ...
                if (!ModelState.IsValid)
                {
                    XException.InvalidArgs.Throw();
                }
                await ValidationProvider
                    .GroupValidationBuilder()
                    .AddNotEmpty(query)
                    .ValidateGroupAsync();

                //
                var result = await provider.FindMany(
                    orderBuilder: !useDefaultOrders
                        ? null
                        : defaultOrderBuilder,
                    includeBuilder: !useDefaultIncludes
                        ? null
                        : defaultIncludeBuilder,
                    cancellationToken: cancellationToken,
                    predicate: x => x.PropValuesContains(query)
                );

                //
                return Ok(result.ToDynamicObject());
            }
            catch (Exception ex)
            {
                //
                var result = GetExceptionActionResult(ex);
                return result;
            }
        }

        /// <summary>
        /// Retrieve Items based on XQuery Pagination structure ...
        /// </summary>
        /// <param name="query"></param>
        /// <param name="useDefaultOrders"></param>
        /// <param name="useDefaultIncludes"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        [HttpGet("Query")]
        public virtual async Task<ActionResult<XQueryResult<TDto>>> Query(
            [FromQuery] XQuery query,
            [FromQuery] bool useDefaultOrders = false,
            [FromQuery] bool useDefaultIncludes = false,
            CancellationToken cancellationToken = default
        )
        {
            //
            try
            {
                //
                // Validate ...
                if (!ModelState.IsValid)
                {
                    XException.InvalidArgs.Throw();
                }
                await ValidationProvider
                    .GroupValidationBuilder()
                    .AddNotNull(query)
                    .ValidateGroupAsync();

                //
                var result = await provider.Query(
                    query: query,
                    predicate: null,
                    orderBuilder: !useDefaultOrders
                        ? null
                        : defaultOrderBuilder,
                    includeBuilder: !useDefaultIncludes
                        ? null
                        : defaultIncludeBuilder,
                    cancellationToken: cancellationToken
                );

                //
                return Ok(result.ToDynamicObject());
            }
            catch (Exception ex)
            {
                //
                var result = GetExceptionActionResult(ex);
                return result;
            }
        }

        /// <summary>
        /// Retrieve Owned Items based on XQuery Pagination structure ...
        /// </summary>
        /// <param name="query"></param>
        /// <param name="useDefaultOrders"></param>
        /// <param name="useDefaultIncludes"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        [HttpGet("Query/Owned")]
        public virtual async Task<ActionResult<XQueryResult<TDto>>> QueryOwned(
            [FromQuery] XQuery query,
            [FromQuery] bool useDefaultOrders = false,
            [FromQuery] bool useDefaultIncludes = false,
            CancellationToken cancellationToken = default
        )
        {
            //
            try
            {
                //
                // Validate ...
                if (!ModelState.IsValid)
                {
                    XException.InvalidArgs.Throw();
                }
                await ValidationProvider
                    .GroupValidationBuilder()
                    .AddNotNull(query)
                    .ValidateGroupAsync();

                //
                var userInfo = await GetUserInfo();

                //
                var result = await provider.QueryOwned(
                    query: query,
                    predicate: null,
                    userInfo: userInfo,
                    orderBuilder: !useDefaultOrders
                        ? null
                        : defaultOrderBuilder,
                    includeBuilder: !useDefaultIncludes
                        ? null
                        : defaultIncludeBuilder,
                    cancellationToken: cancellationToken
                );

                //
                return Ok(result.ToDynamicObject());
            }
            catch (Exception ex)
            {
                //
                var result = GetExceptionActionResult(ex);
                return result;
            }
        }
        #endregion

        //
        #region Add/Update/Remove ...
        /// <summary>
        /// Add an item ...
        /// </summary>
        /// <param name="item"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        [HttpPost("")]
        public virtual async Task<ActionResult<TDto>> Add(
            [FromBody] TDto item,
            CancellationToken cancellationToken = default
        )
        {
            //
            try
            {
                //
                // Validate ...
                if (!ModelState.IsValid)
                {
                    XException.InvalidArgs.Throw();
                }
                await ValidationProvider
                    .GroupValidationBuilder()
                    .AddNotNull(item)
                    .ValidateGroupAsync();

                //
                var userInfo = await GetUserInfo();
                var connectionId = GetConnectionId();

                //
                var result = await provider.Add(
                    item: item,
                    userInfo: userInfo,
                    connectionId: connectionId,
                    cancellationToken: cancellationToken
                );

                //
                return Ok(result.ToDynamicObject());
            }
            catch (Exception ex)
            {
                //
                var result = GetExceptionActionResult(ex);
                return result;
            }
        }

        /// <summary>
        /// Update an item values ...
        /// </summary>
        /// <param name="id"></param>
        /// <param name="item"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        [HttpPut("{id}")]
        public virtual async Task<ActionResult<TDto>> Update(
            [FromRoute] TKey id,
            [FromBody] TDto item,
            CancellationToken cancellationToken = default
        )
        {
            //
            try
            {
                //
                // Validate ...
                if (!ModelState.IsValid)
                {
                    XException.InvalidArgs.Throw();
                }
                await ValidationProvider
                    .GroupValidationBuilder()
                    .AddNotNull(id)
                    .AddNotNull(item)
                    .ValidateGroupAsync();

                //
                var userInfo = await GetUserInfo();
                var connectionId = GetConnectionId();

                //
                var result = await provider.Update(
                    id: id,
                    item: item,
                    userInfo: userInfo,
                    connectionId: connectionId,
                    cancellationToken: cancellationToken
                );

                //
                return Ok(result.ToDynamicObject());
            }
            catch (Exception ex)
            {
                //
                var result = GetExceptionActionResult(ex);
                return result;
            }
        }

        /// <summary>
        /// Remove an Item ...
        /// </summary>
        /// <param name="id"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        [HttpDelete("{id}")]
        public virtual async Task<ActionResult<TDto>> Remove(
            [FromRoute] TKey id,
            CancellationToken cancellationToken = default
        )
        {
            //
            try
            {
                //
                // Validate ...
                if (!ModelState.IsValid)
                {
                    XException.InvalidArgs.Throw();
                }
                await ValidationProvider
                    .GroupValidationBuilder()
                    .AddNotNull(id)
                    .ValidateGroupAsync();

                //
                var userInfo = await GetUserInfo();
                var connectionId = GetConnectionId();

                //
                var result = await provider.Remove(
                    id: id,
                    userInfo: userInfo,
                    connectionId: connectionId,
                    cancellationToken: cancellationToken
                );

                //
                return Ok(result.ToDynamicObject());
            }
            catch (Exception ex)
            {
                //
                var result = GetExceptionActionResult(ex);
                return result;
            }
        }
        #endregion
    }
}