using Microsoft.Extensions.Options;
using MongoDB.Driver;
using UGQDataAccess.Repository.Models;
using UGQDataAccess.Settings;
using UGQDatabase.Models;

public enum AccountGradeSortType
{
    UpdatedAtAsc,
    UpdatedAtDesc,
    GradeAsc,
    GradeDesc,
    ReservedAtAsc,
    ReservedDesc,
}

public enum AccountGradeProcessType
{
    All,
    Processing,
    Completed,
}

namespace UGQDataAccess.Repository
{
    public class ReserveAccountGradeRepository : BaseRepository<ReserveAccountGradeEntity>
    {
        private const string CollectionName = "ReserveAccountGrade";

        public ReserveAccountGradeRepository(IMongoClient mongoClient, IOptions<UGQDatabaseSettings> settings) :
            base(mongoClient, settings.Value.DatabaseName, CollectionName)
        {
        }

        public async Task<ReserveAccountGradeEntity?> get(string userGuid)
        {
            var builder = Builders<ReserveAccountGradeEntity>.Filter;
            var filter = builder.Eq(x => x.IsCompleted, false);
            filter &= builder.Eq(x => x.UserGuid, userGuid);

            return await Collection.Find(filter).FirstOrDefaultAsync();
        }

        public async Task<List<ReserveAccountGradeEntity>> get(string userGuid, AccountGradeProcessType processType)
        {
            var builder = Builders<ReserveAccountGradeEntity>.Filter;
            var filter = builder.Eq(x => x.UserGuid, userGuid);

            switch (processType)
            {
                case AccountGradeProcessType.Processing:
                    filter &= builder.Eq(x => x.IsCompleted, false);
                    break;
                case AccountGradeProcessType.Completed:
                    filter &= builder.Eq(x => x.IsCompleted, true);
                    break;
                case AccountGradeProcessType.All:
                default:
                    break;
            }

            return await Collection.Find(filter).ToListAsync();
        }

        public async Task<long> getAllCount()
        {
            var builder = Builders<ReserveAccountGradeEntity>.Filter;
            var filter = builder.Empty;

            var result = await Collection.Find(filter).CountDocumentsAsync();
            return result;
        }

        public async Task<ReserveAccountGradeEntity> reserveAccountGrade(string userGuid, UgqGradeType beforeGrade, UgqGradeType reserveGrade, DateTime reserveTime)
        {
            var entity = new ReserveAccountGradeEntity
            {
                UserGuid = userGuid,
                BeforeGradeType = beforeGrade,
                ReserveGradeType = reserveGrade,
                ReserveTime = reserveTime,
                UpdatedAt = DateTime.UtcNow,
                IsCompleted = false,
            };

            await Collection.InsertOneAsync(entity);
            return entity;
        }

        public async Task<ReserveAccountGradeEntity> modifyReserveAccountGrade(string reserveId, UgqGradeType reserveGrade, DateTime reserveTime)
        {
            var builder = Builders<ReserveAccountGradeEntity>.Filter;
            var filter = builder.Eq(x => x.IsCompleted, false);

            filter &= builder.Eq(x => x.Id, reserveId);

            var update = Builders<ReserveAccountGradeEntity>.Update
                .Set(x => x.ReserveGradeType, reserveGrade)
                .Set(x => x.ReserveTime, reserveTime)
                .Set(x => x.UpdatedAt, DateTime.UtcNow);

            var options = new FindOneAndUpdateOptions<ReserveAccountGradeEntity>
            {
                ReturnDocument = ReturnDocument.After,
            };

            return await Collection.FindOneAndUpdateAsync(filter, update, options);
        }

        public async Task<List<ReserveAccountGradeEntity>> completeReserveAccountGrade()
        {
            var builder = Builders<ReserveAccountGradeEntity>.Filter;
            var filter = builder.Eq(x => x.IsCompleted, false);
            filter &= builder.Lte(x => x.ReserveTime, DateTime.UtcNow);

            var update = Builders<ReserveAccountGradeEntity>.Update
                .Set(x => x.IsCompleted, true)
                .Set(x => x.UpdatedAt, DateTime.UtcNow);

            var result = await Collection.Find(filter).ToListAsync();
            await Collection.UpdateManyAsync(filter, update);
            return result;
        }

        public async Task<ServerErrorCode> deleteReserveAccountGrade(string reserveId)
        {
            var builder = Builders<ReserveAccountGradeEntity>.Filter;
            var filter = builder.Eq(x => x.IsCompleted, false);
            filter &= builder.Eq(x => x.Id, reserveId);

            var result = await Collection.DeleteOneAsync(filter);
            if (result.DeletedCount == 0)
                return ServerErrorCode.UgqNullEntity;
            
            return ServerErrorCode.Success;
        }

        public async Task<AllReserveAccountGradeResult> getAccounts(int pageNumber, int pageSize, AccountGradeSortType sortType, AccountGradeProcessType processType, string userGuid)
        {
            pageNumber = pageNumber < 1 ? 1 : pageNumber;

            var builder = Builders<ReserveAccountGradeEntity>.Filter;
            var filter = Builders<ReserveAccountGradeEntity>.Filter.Empty;

            switch (processType)
            {
                case AccountGradeProcessType.Processing:
                    filter = builder.Eq(x => x.IsCompleted, false);
                    break;
                case AccountGradeProcessType.Completed:
                    filter = builder.Eq(x => x.IsCompleted, true);
                    break;
                case AccountGradeProcessType.All:
                default:
                    break;
            }

            if(userGuid != string.Empty)
                filter &= builder.Eq(x => x.UserGuid, userGuid);

            var sortBuilder = Builders<ReserveAccountGradeItemResult>.Sort;
            SortDefinition<ReserveAccountGradeItemResult> sort;
            switch (sortType)
            {
                case AccountGradeSortType.UpdatedAtAsc:
                    sort = Builders<ReserveAccountGradeItemResult>.Sort.Ascending("UpdatedAt");
                    break;
                case AccountGradeSortType.UpdatedAtDesc:
                    sort = Builders<ReserveAccountGradeItemResult>.Sort.Descending("UpdatedAt");
                    break;
                case AccountGradeSortType.GradeAsc:
                    sort = Builders<ReserveAccountGradeItemResult>.Sort.Ascending("CurrentGradeType");
                    break;
                case AccountGradeSortType.GradeDesc:
                    sort = Builders<ReserveAccountGradeItemResult>.Sort.Descending("CurrentGradeType");
                    break;
                case AccountGradeSortType.ReservedAtAsc:
                    sort = Builders<ReserveAccountGradeItemResult>.Sort.Ascending("ReserveTime");
                    break;
                case AccountGradeSortType.ReservedDesc:
                    sort = Builders<ReserveAccountGradeItemResult>.Sort.Descending("ReserveTime");
                    break;
                default:
                    sort = Builders<ReserveAccountGradeItemResult>.Sort.Descending("UpdatedAt");
                    break;
            }

            var countFacet = AggregateFacet.Create("count",
            new EmptyPipelineDefinition<ReserveAccountGradeItemResult>()
                .Count()
                );

            var pagingFacet = AggregateFacet.Create("paging",
                new EmptyPipelineDefinition<ReserveAccountGradeItemResult>()
                    .Sort(sort)
                    .Skip((pageNumber - 1) * pageSize)
                    .Limit(pageSize)
                    );

            var pipeline = ReserveAccountGradeQuery.allReserveAccountGradePipeline<ReserveAccountGradeItemResult>(
                filter,
                ReserveAccountGradeQuery.ReserveAccountGradeItemResultProjection)
                .Facet(countFacet, pagingFacet);

            var aggregation = await (await Collection.AggregateAsync(pipeline)).ToListAsync();
            var count = aggregation.First()
                .Facets.First(x => x.Name == "count")
                .Output<AggregateCountResult>()
                ?.FirstOrDefault()
                ?.Count;

            var paging = aggregation.First()
                .Facets.First(x => x.Name == "paging")
                .Output<ReserveAccountGradeItemResult>();

            int totalPages = 0;
            if (count != null)
                totalPages = (int)Math.Ceiling((double)count / pageSize);

            var result = await (await Collection.AggregateAsync(pipeline)).ToListAsync();
            return new AllReserveAccountGradeResult
            {
                PageNumber = pageNumber,
                PageSize = pageSize,
                TotalPages = totalPages,
                Items = paging.ToList(),
            };
        }
    }
}