using System.Globalization;
using System.Linq.Expressions;
using System.Reflection;
using AutoMapPropertyHelper;
using EntityFrameworkCore.Projectables;
using Microsoft.AspNetCore.Http.HttpResults;
using Microsoft.EntityFrameworkCore;

namespace NejCommon.Models;


    public abstract class CommonDbContext : DbContext
    {
        public CommonDbContext() : base()
        {
        }
        public CommonDbContext(DbContextOptions options)
            : base(options)
        {
        }

        public abstract CommonDbContext CreateCopy();

        public async Task<bool> ApiSaveChangesAsync()
        {
            try
            {
                await SaveChangesAsync();
                return true;
            }
            catch (Exception ex)
            {
                Console.WriteLine("Error saving db: " + ex.Message);
                Console.WriteLine(ex.StackTrace);
                return false;
            }
        }

        public static BadRequest<Error> SaveError = TypedResults.BadRequest(new Error
        {
            Message = "Error saving data to database"
        });

        public async Task<Results<BadRequest<Error>, T1>> ApiSaveChangesAsync<T1>(T1 value) where T1 : IResult
        {
            var res = await ApiSaveChangesAsync();

            if (res)
                return value;
            else
                return SaveError;
        }
        public async Task<Results<BadRequest<Error>, CreatedAtRoute<T2>>> ApiSaveChangesAsyncCreate<T1, T2>(IServiceProvider providers, T1 value, bool apply = true) where T2 : IAutomappedAttribute<T1, T2>, new()
        {
            if (!apply)
                return TypedResults.CreatedAtRoute(new T2().ApplyFrom(providers, value));

            var res = await ApiSaveChangesAsync();

            if (res)
                return TypedResults.CreatedAtRoute(new T2().ApplyFrom(providers, value));
            else
                return SaveError;
        }
        public async Task<Results<BadRequest<Error>, Ok<T2>>> ApiSaveChangesAsyncOk<T1, T2>(IServiceProvider providers, T1 value, bool apply = true) where T2 : IAutomappedAttribute<T1, T2>, new()
        {
            if (!apply)
                return TypedResults.Ok(new T2().ApplyFrom(providers, value));

            var res = await ApiSaveChangesAsync();

            if (res)
                return TypedResults.Ok(new T2().ApplyFrom(providers, value));
            else
                return SaveError;
        }
        public async Task<T> FindOrCreateAsync<T>(Expression<Func<T, bool>> predicate, Func<T> factory) where T : class
        {
            var entity = ChangeTracker.Entries<T>().Select(x => x.Entity).FirstOrDefault(predicate.Compile());

            //find in change tracker
            if (entity != null && Entry(entity).State == EntityState.Deleted)
            {
                Entry(entity).State = EntityState.Modified;
            }

            //find in currentDb
            if (entity == null)
            {
                entity = await Set<T>().FirstOrDefaultAsync(predicate);
            }

            //find in up-to-date db
            if (entity == null)
            {
                var newAppDB = CreateCopy();

                entity = await newAppDB.Set<T>().FirstOrDefaultAsync(predicate);

                //track the entity if it's not null and not already being tracked
                if (entity != null && this.Entry(entity).State == EntityState.Detached)
                    Attach(entity);
            }

            //create if not found
            if (entity == null)
            {
                var newEntity = factory();
                await this.AddAsync(newEntity);
                entity = newEntity;
            }

            return entity;
        }
        public T FindOrCreate<T>(Expression<Func<T, bool>> predicate, Func<T> factory) where T : class
        {
            var entity = ChangeTracker.Entries<T>().Where(e => e.State != EntityState.Deleted).Select(x => x.Entity).FirstOrDefault(predicate.Compile());
            
            //find in change tracker
            if (entity != null && Entry(entity).State == EntityState.Deleted)
            {
                Entry(entity).State = EntityState.Modified;
            }
            
            //find in currentDb
            if (entity == null)
            {
                entity = Set<T>().FirstOrDefault(predicate);
            }
            
            //find in up-to-date db
            if (entity == null)
            {
                var newAppDB = CreateCopy();

                entity = newAppDB.Set<T>().FirstOrDefault(predicate);
                if (entity != null)
                    Attach(entity);
            }

            //create if not found
            if (entity == null)
            {
                var newEntity = factory();
                this.Add(newEntity);
                entity = newEntity;
            }

            return entity;
        }

        public T Create<T>(Action<T> config = null, params object[] constructorArguments)
        {
            var entity = this.CreateProxy<T>(constructorArguments);

            config?.Invoke(entity);
            this.Add(entity);
            this.ChangeTracker.DetectChanges();
            return entity;
        }

        public void ApplyRelationships()
        {
            this.ChangeTracker.DetectChanges();
        }
    }