using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using Luticate2.Auth.Tests.DataAccess.Crud.Models;
using Luticate2.Auth.Utils.Business.Converters;
using Luticate2.Auth.Utils.Business.Converters.ObjectConverterDescriptor;
using Luticate2.Auth.Utils.Business.Fields;
using Luticate2.Auth.Utils.DataAccess.Crud;
using Luticate2.Auth.Utils.Dbo;
using Luticate2.Auth.Utils.Dbo.Fields;
using Luticate2.Auth.Utils.Dbo.Pagination;
using Luticate2.Auth.Utils.Dbo.Result;
using Luticate2.Auth.Utils.Interfaces;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
using Xunit;

namespace Luticate2.Auth.Tests.DataAccess.Crud
{
    public class LuEfCrudTests : IDisposable
    {
        public class TableSimple1Dbo
        {
            public Guid Id { get; set; }

            public string Name { get; set; }

            public int Priority { get; set; }

            public string Comment { get; set; }

            public int? OptionalInt { get; set; }

            public DateTime CreatedAt { get; set; }

            public DateTime? UpdatedAt { get; set; }
        }

        public class TableSimple1DboDescriptor : LuObjectConverterDescriptor<TableSimple1Dbo, table_simple_1>
        {
            public TableSimple1DboDescriptor()
            {
                AddStaticMemberConverter(dbo => dbo.Id, model => model.id);
                AddStaticMemberConverter(dbo => dbo.Name, model => model.name);
                AddStaticMemberConverter(dbo => dbo.Priority, model => model.priority);
                AddStaticMemberConverter(dbo => dbo.Comment, model => model.comment);
                AddStaticMemberConverter(dbo => dbo.OptionalInt, model => model.optional_int);
                AddStaticMemberConverter(dbo => dbo.CreatedAt, model => model.created_at);
                AddStaticMemberConverter(dbo => dbo.UpdatedAt, model => model.updated_at);
            }
        }

        public class TableSimple1ModelDescriptor : LuObjectConverterDescriptor<table_simple_1, TableSimple1Dbo>
        {
            public TableSimple1ModelDescriptor()
            {
                AddStaticMemberConverter(model => model.id, dbo => dbo.Id);
                AddStaticMemberConverter(model => model.name, dbo => dbo.Name);
                AddStaticMemberConverter(model => model.priority, dbo => dbo.Priority);
                AddStaticMemberConverter(model => model.comment, dbo => dbo.Comment);
                AddStaticMemberConverter(model => model.optional_int, dbo => dbo.OptionalInt);
                AddStaticMemberConverter(model => model.created_at, dbo => dbo.CreatedAt);
                AddStaticMemberConverter(model => model.updated_at, dbo => dbo.UpdatedAt);
            }
        }

        public class TableSimple1DataAccess : LuEfCrudDataAccess<TableSimple1Dbo, table_simple_1, luticate2_unit_testsContext>
        {
            public TableSimple1DataAccess(IServiceProvider serviceProvider) : base(serviceProvider)
            {
            }
        }

        public IServiceProvider ServiceProvider { get; set; }

        public luticate2_unit_testsContext Luticate2UnitTestsContext { get; set; }

        public LuEfCrudTests()
        {
            var services = new ServiceCollection();
            services.AddLuObjectConverterDescriptors();
            // DB read
            services.AddSingleton<ILuObjectConverterDescriptor<TableSimple1Dbo, table_simple_1>, TableSimple1DboDescriptor>();
            // DB write
            services.AddSingleton<ILuObjectConverterDescriptor<table_simple_1, TableSimple1Dbo>, TableSimple1ModelDescriptor>();

            services.AddLuObjectConverters();
            // DB read
            services.AddLuObjectConverterPoco<table_simple_1, TableSimple1Dbo>();
            // DB write
            services.AddLuObjectConverterPoco<TableSimple1Dbo, table_simple_1>();


            services.AddSingleton<ILuConvertersTypeConverter>(new LuConvertersTypeConverter(new Dictionary<Type, Type>
            {
                {typeof(TableSimple1Dbo), typeof(table_simple_1)} // DB read
            }));

            services.AddDbContext<luticate2_unit_testsContext>(options =>
            {
                options.UseNpgsql(@"Host=localhost;Database=luticate2_unit_tests;Username=dev;Password=dev");
                options.UseInternalServiceProvider(new ServiceCollection()
                    .AddEntityFrameworkNpgsql()
                    .BuildServiceProvider());
            }, ServiceLifetime.Transient);

            services.AddSingleton<TableSimple1DataAccess>();

            ServiceProvider = services.BuildServiceProvider();
            Luticate2UnitTestsContext = ServiceProvider.GetService<luticate2_unit_testsContext>();
            Luticate2UnitTestsContext.table_simple_1.RemoveRange(Luticate2UnitTestsContext.table_simple_1);
            Luticate2UnitTestsContext.SaveChanges();
        }

        public void Dispose()
        {
            Luticate2UnitTestsContext.table_simple_1.RemoveRange(Luticate2UnitTestsContext.table_simple_1);
            Luticate2UnitTestsContext.SaveChanges();
        }

        protected void AddTableSimple1DataSet1()
        {
            Luticate2UnitTestsContext.table_simple_1.AddRange(new table_simple_1
            {
                name = "test2",
                priority = 24,
                comment = null,
                optional_int = 1,
                created_at = DateTime.Now,
                updated_at = null
            }, new table_simple_1
            {
                name = "test1",
                priority = 42,
                comment = null,
                optional_int = null,
                created_at = DateTime.Now,
                updated_at = null
            });
            Luticate2UnitTestsContext.SaveChanges();
        }

        [Fact]
        public void TestSimpleReadFilter1()
        {
            AddTableSimple1DataSet1();

            var crudDataAccess = ServiceProvider.GetRequiredService<TableSimple1DataAccess>();

            var result = crudDataAccess.Read(LuPartialFieldsParser.Parse("*").Data, new LuPaginatedParamsDbo
            {
                Filter = new LuFilterDbo
                {
                    Expression = (Expression<Func<TableSimple1Dbo, bool>>) (x => x.Name == "test1")
                },
                Page = 0,
                OrderBy = new LuOrderByDbo
                {
                    OrderByFields = new List<LuOrderByFieldDbo>()
                },
                PerPage = 10
            });
            Assert.NotNull(result);
            Assert.Equal(LuStatus.Success.ToInt(), result.Status);
            var items = result.Data;
            Assert.NotNull(items);
            Assert.Equal(1, items.Count);
            Assert.NotNull(items.Data);
            Assert.Equal(1, items.Data.Count);

            var item = items.Data[0];
            Assert.NotNull(item);
            Assert.Equal("test1", item.Name);
            Assert.Equal(42, item.Priority);
            Assert.Null(item.Comment);
            Assert.Null(item.OptionalInt);
        }

        [Fact]
        public void TestSimpleReadOrderBy1()
        {
            AddTableSimple1DataSet1();

            var crudDataAccess = ServiceProvider.GetRequiredService<TableSimple1DataAccess>();

            var result = crudDataAccess.Read(LuPartialFieldsParser.Parse("*").Data, new LuPaginatedParamsDbo
            {
                Filter = new LuFilterDbo
                {
                    Expression = (Expression<Func<TableSimple1Dbo, bool>>) (x => x.Name == "test1" || x.Name == "test2")
                },
                Page = 0,
                OrderBy = new LuOrderByDbo
                {
                    OrderByFields = new List<LuOrderByFieldDbo>
                    {
                        new LuOrderByFieldDbo
                        {
                            Asc = true,
                            Expression = (Expression<Func<TableSimple1Dbo, object>>) (x => x.Priority)
                        }
                    }
                },
                PerPage = 10
            });
            Assert.NotNull(result);
            Assert.Equal(LuStatus.Success.ToInt(), result.Status);
            var items = result.Data;
            Assert.NotNull(items);
            Assert.Equal(2, items.Count);
            Assert.NotNull(items.Data);
            Assert.Equal(2, items.Data.Count);

            var item = items.Data[0];
            Assert.NotNull(item);
            Assert.Equal("test2", item.Name);
            Assert.Equal(24, item.Priority);
            Assert.Null(item.Comment);
            Assert.Equal(1, item.OptionalInt);

            item = items.Data[1];
            Assert.NotNull(item);
            Assert.Equal("test1", item.Name);
            Assert.Equal(42, item.Priority);
            Assert.Null(item.Comment);
            Assert.Null(item.OptionalInt);
        }

        [Fact]
        public void TestSimpleReadOrderBy2()
        {
            AddTableSimple1DataSet1();

            var crudDataAccess = ServiceProvider.GetRequiredService<TableSimple1DataAccess>();

            var partialResponse = new LuPartialFieldsDbo
            {
                Fields = new List<LuFieldDbo>
                {
                    new LuFieldDbo
                    {
                        Parts = new List<string>
                        {
                            "*"
                        }
                    }
                }
            };

            var paginationParams = new LuPaginatedParamsDbo
            {
                Filter = new LuFilterDbo
                {
                    Expression = (Expression<Func<TableSimple1Dbo, bool>>) (x => x.Name == "test1" || x.Name == "test2")
                },
                Page = 0,
                OrderBy = new LuOrderByDbo
                {
                    OrderByFields = new List<LuOrderByFieldDbo>
                    {
                        new LuOrderByFieldDbo
                        {
                            Asc = false,
                            Expression = (Expression<Func<TableSimple1Dbo, object>>) (x => x.Priority)
                        }
                    }
                },
                PerPage = 10
            };

            var result = crudDataAccess.Read(partialResponse, paginationParams);
            Assert.NotNull(result);
            Assert.Equal(LuStatus.Success.ToInt(), result.Status);
            var items = result.Data;
            Assert.NotNull(items);
            Assert.Equal(2, items.Count);
            Assert.NotNull(items.Data);
            Assert.Equal(2, items.Data.Count);

            var item = items.Data[0];
            Assert.NotNull(item);
            Assert.Equal("test1", item.Name);
            Assert.Equal(42, item.Priority);
            Assert.Null(item.Comment);
            Assert.Null(item.OptionalInt);

            item = items.Data[1];
            Assert.NotNull(item);
            Assert.Equal("test2", item.Name);
            Assert.Equal(24, item.Priority);
            Assert.Null(item.Comment);
            Assert.Equal(1, item.OptionalInt);
        }

        [Fact]
        public void TestSimpleCreate1()
        {
            var crudDataAccess = ServiceProvider.GetRequiredService<TableSimple1DataAccess>();

            var partialInput = new LuPartialFieldsDbo
            {
                Fields = new List<LuFieldDbo>
                {
                    new LuFieldDbo
                    {
                        Parts = new List<string>
                        {
                            "*"
                        }
                    }
                }
            };

            var partialResponse = new LuPartialFieldsDbo
            {
                Fields = new List<LuFieldDbo>
                {
                    new LuFieldDbo
                    {
                        Parts = new List<string>
                        {
                            "*"
                        }
                    }
                }
            };

            var objects = new List<TableSimple1Dbo>
            {
                new TableSimple1Dbo
                {
                    Name = "test2",
                    Priority = 24,
                    Comment = null,
                    OptionalInt = 1,
                    CreatedAt = DateTime.Now,
                    UpdatedAt = null
                }, new TableSimple1Dbo
                {
                    Name = "test1",
                    Priority = 42,
                    Comment = null,
                    OptionalInt = null,
                    CreatedAt = DateTime.Now,
                    UpdatedAt = null
                }
            };

            var result = crudDataAccess.Create(partialResponse, partialInput, objects);

            Assert.NotNull(result);
            Assert.Equal(LuStatus.Success.ToInt(), result.Status);
            var items = result.Data;
            Assert.NotNull(items);
            Assert.Equal(objects.Count, items.Count);

            foreach (var o in items.Zip(objects, (added, origin) => new { Added = added, Origin = origin }))
            {
                Assert.NotNull(o.Added);
                Assert.Equal(o.Origin.Name, o.Added.Name);
                Assert.Equal(o.Origin.Priority, o.Added.Priority);
                Assert.Equal(o.Origin.Comment, o.Added.Comment);
                Assert.Equal(o.Origin.OptionalInt, o.Added.OptionalInt);
            }
        }

        [Fact]
        public void TestSimpleCreate2()
        {
            var crudDataAccess = ServiceProvider.GetRequiredService<TableSimple1DataAccess>();

            var partialInput = new LuPartialFieldsDbo
            {
                Fields = new List<LuFieldDbo>
                {
                    new LuFieldDbo
                    {
                        Parts = new List<string>
                        {
                            "*"
                        }
                    }
                }
            };

            var partialResponse = new LuPartialFieldsDbo
            {
                Fields = new List<LuFieldDbo>
                {
                    new LuFieldDbo
                    {
                        Parts = new List<string>
                        {
                            "id"
                        }
                    },
                    new LuFieldDbo
                    {
                        Parts = new List<string>
                        {
                            "name"
                        }
                    }
                }
            };

            var objects = new List<TableSimple1Dbo>
            {
                new TableSimple1Dbo
                {
                    Name = "test2",
                    Priority = 24,
                    Comment = null,
                    OptionalInt = 1,
                    CreatedAt = DateTime.Now,
                    UpdatedAt = null
                }, new TableSimple1Dbo
                {
                    Name = "test1",
                    Priority = 42,
                    Comment = null,
                    OptionalInt = null,
                    CreatedAt = DateTime.Now,
                    UpdatedAt = null
                }
            };

            var result = crudDataAccess.Create(partialResponse, partialInput, objects);

            Assert.NotNull(result);
            Assert.Equal(LuStatus.Success.ToInt(), result.Status);
            var items = result.Data;
            Assert.NotNull(items);
            Assert.Equal(objects.Count, items.Count);

            foreach (var o in items.Zip(objects, (added, origin) => new { Added = added, Origin = origin }))
            {
                Assert.NotNull(o.Added);
                Assert.Equal(o.Origin.Name, o.Added.Name);
                Assert.Equal(0, o.Added.Priority);
                Assert.Null(o.Added.Comment);
                Assert.Null(o.Added.OptionalInt);
            }
        }

        [Fact]
        public void TestSimpleDelete1()
        {
            AddTableSimple1DataSet1();

            var crudDataAccess = ServiceProvider.GetRequiredService<TableSimple1DataAccess>();

            var partialResponse = new LuPartialFieldsDbo
            {
                Fields = new List<LuFieldDbo>
                {
                    new LuFieldDbo
                    {
                        Parts = new List<string>
                        {
                            "*"
                        }
                    }
                }
            };

            var paginationParams = new LuPaginatedParamsDbo
            {
                Filter = new LuFilterDbo
                {
                    Expression = (Expression<Func<TableSimple1Dbo, bool>>) (x => x.Name == "test1")
                },
                Page = 0,
                OrderBy = new LuOrderByDbo
                {
                    OrderByFields = new List<LuOrderByFieldDbo>
                    {
                        new LuOrderByFieldDbo
                        {
                            Asc = false,
                            Expression = (Expression<Func<TableSimple1Dbo, object>>) (x => x.Name)
                        }
                    }
                },
                PerPage = 10
            };

            var result = crudDataAccess.Delete(partialResponse, paginationParams);
            Assert.NotNull(result);
            Assert.Equal(LuStatus.Success.ToInt(), result.Status);
            var items = result.Data;
            Assert.NotNull(items);
            Assert.Equal(1, items.Count);

            var item = items.Data[0];
            Assert.NotNull(item);
            Assert.Equal("test1", item.Name);
            Assert.Equal(42, item.Priority);
            Assert.Null(item.Comment);
            Assert.Null(item.OptionalInt);
        }

        [Fact]
        public void TestSimpleDelete2()
        {
            AddTableSimple1DataSet1();

            var crudDataAccess = ServiceProvider.GetRequiredService<TableSimple1DataAccess>();

            var partialResponse = new LuPartialFieldsDbo
            {
                Fields = new List<LuFieldDbo>
                {
                    new LuFieldDbo
                    {
                        Parts = new List<string>
                        {
                            "*"
                        }
                    }
                }
            };

            var paginationParams = new LuPaginatedParamsDbo
            {
                Filter = new LuFilterDbo
                {
                    Expression = (Expression<Func<TableSimple1Dbo, bool>>) (x => x.Name == "test1" || x.Name == "test2")
                },
                Page = 0,
                OrderBy = new LuOrderByDbo
                {
                    OrderByFields = new List<LuOrderByFieldDbo>
                    {
                        new LuOrderByFieldDbo
                        {
                            Asc = false,
                            Expression = (Expression<Func<TableSimple1Dbo, object>>) (x => x.Name)
                        }
                    }
                },
                PerPage = 10
            };

            var result = crudDataAccess.Delete(partialResponse, paginationParams);
            Assert.NotNull(result);
            Assert.Equal(LuStatus.Success.ToInt(), result.Status);
            var items = result.Data;
            Assert.NotNull(items);
            Assert.Equal(2, items.Count);

            var item = items.Data[0];
            Assert.NotNull(item);
            Assert.Equal("test2", item.Name);
            Assert.Equal(24, item.Priority);
            Assert.Null(item.Comment);
            Assert.Equal(1, item.OptionalInt);

            item = items.Data[1];
            Assert.NotNull(item);
            Assert.Equal("test1", item.Name);
            Assert.Equal(42, item.Priority);
            Assert.Null(item.Comment);
            Assert.Null(item.OptionalInt);
        }
    }
}