using Datamodels.BusinessModels;
using Datamodels.DatabaseModels;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.Logging;
using Repositories.Interfaces;
using System;
using System.Collections.Generic;
using System.Text;
using System.Threading.Tasks;
using System.Linq;
using Microsoft.EntityFrameworkCore;
using Datamodels.SearchModels;
using System.Linq.Expressions;
using System.Diagnostics;

namespace Repositories
{
    public class FwMariaSearchRepo : IFwMariaSearchRepo
    {
        private readonly FwDbContext _dbContext = new FwDbContext();
        private readonly ILogger<FwMariaSearchRepo> _logger;
        private readonly IConfiguration _configuration;

        public FwMariaSearchRepo(ILogger<FwMariaSearchRepo> logger, IConfiguration configuration)
        {
            _logger = logger;
            _configuration = configuration;
            try
            {
                if (Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT") == "Development")
                {
                    _dbContext._connectionString = "SERVER=127.0.0.1;DATABASE=testdb;PORT=3306;USER=root;PASSWORD=example";
                }
                else
                {
                    string usedDb = configuration.GetSection("GeneralSettings").GetSection("DbToUse").Get<string>();
                    string connectionString = configuration.GetConnectionString(usedDb);
                    _dbContext._connectionString = connectionString;
                }
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Database Connection Configuration not valid");
            }
        }

        public async Task<DataResult<List<Address>>> GetAllAddresses()
        {
            try
            {
                var result = await _dbContext.Address.Where(x => x.City == "Augsburg" || x.City == "München").Where(y => y.StreetName.Contains("bruck")).ToListAsync().ConfigureAwait(false);
                return new DataResult<List<Address>> { Data = result };
            }
            catch (Exception ex)
            {
                return new DataResult<List<Address>>
                {
                    GeneralResult = GeneralResults.DatabaseError,
                    UserMessage = "Fehler beim Laden der Adressen",
                    ServerMessage = ex.Message
                };
            }
        }

        public Task<object> GetAllSortedData(TableModel queryFieldDef, List<SortModel> sortModel)
        {
            throw new NotImplementedException();
        }

        public Task<string> GetBlobData(string tableName, string fieldName, long id)
        {
            throw new NotImplementedException();
        }

        public Task<object> GetDataFilteredAndSorted(List<FilterModel> filter, List<SortModel> sortModel, long skip = 0, long take = -1)
        {
            throw new NotImplementedException();
        }

        public async Task<DataResult<List<IEntityClass>>> GetFilteredData<T>(List<Expression> expressions, long skip = 0, long take = -1) where T : IEntityClass
        {

            var where = FilterLinq<T>.GetWherePredicate(wherefield, wherefieldvalue).Compile();
            items = await _dbContext.Address.Where((Expression<Func<Address, bool>>)where).ToListAsync();
            var result = new DataResult<List<IEntityClass>>();
            if (typeof(T).Equals(typeof(Address)))
            {
                Expression combined = null;
                foreach (var exp in expressions)
                {
                    if (combined == null)
                    {
                        combined = exp;
                    }
                    else
                    {
                        combined = Expression.Or(combined, exp);
                    }
                }
                ParameterExpression pe = Expression.Parameter(typeof(T), typeof(T).Name);
                combined = Expression.Lambda<Func<T, Boolean>>(combined, new ParameterExpression[] { pe });
                //var addressFound = await _dbContext.Address.Where((Expression<Func<Address, bool>>)combined).ToListAsync();
                var addressFound = await _dbContext.Address.Where(a => a.City == "Augsburg" | a.City == "München").ToListAsync();
                result.Data = new List<IEntityClass>(addressFound.Cast<IEntityClass>());
                
            }
            
            return result;
        }
    }

    public class FilterLinq<T>
    {
        public static Expression<Func<T, Boolean>> GetWherePredicate(string whereFieldList, string whereFieldValues)
        {
            //the 'IN' parameter for expression ie T=> condition
            ParameterExpression pe = Expression.Parameter(typeof(T), typeof(T).Name);

            //combine them with and 1=1 Like no expression
            Expression combined = null;
            if (whereFieldList != null)
            {
                string[] field = whereFieldList.Split(';');
                string[] fieldValue = whereFieldValues.Split(';');
                for (int i = 0; i < field.Count(); i++)
                {
                    //Expression for accessing Fields name property
                    Expression columnNameProperty = Expression.Property(pe, field[i]);

                    //the name constant to match 
                    Expression columnValue = Expression.Constant(fieldValue[i]);

                    //the first expression: PatientantLastName = ?
                    Expression e1 = Expression.Equal(columnNameProperty, columnValue);

                    if (combined == null)
                    {
                        combined = e1;
                    }
                    else
                    {
                        combined = Expression.And(combined, e1);
                    }
                }
            }

            //create and return the predicate
            return Expression.Lambda<Func<T, Boolean>>(combined, new ParameterExpression[] { pe });
        }
    }
}