using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using MapsDb.Interfaces;
using MapsDb.Models;
using MapsModels.DsModels;
using System.Reflection;
using Microsoft.EntityFrameworkCore;

namespace MapsDb.DataService
{
    public class RoadDs : IRoadDs
    {
        private PostgresDbContext _context;
        public RoadDs(){
            _context = new PostgresDbContext();
        }
        public Task<IList<RoadSelectListDsM>> GetSelectListAsync(){
            return Task.Factory.StartNew(GetSelectList);
        }
        private IList<RoadSelectListDsM> GetSelectList()
        {
           return _context.Road.Select(x => new RoadSelectListDsM
            {
                RoadId = x.Id, 
                Name = x.Name
            }).ToList();
        }

        public Task<IList<RoadEditDsM>> GetIndexListAsync(PaginationDsM pagination){
            return Task.Factory.StartNew(()=> { return GetAllRoad(pagination); });
        }
        private IList<RoadEditDsM> GetAllRoad(PaginationDsM pagination)
        {
            var data =  _context.Road.Select(Road => new RoadEditDsM
            {
                Id = Road.Id,
                Name = Road.Name,
                Value = Road.Value,
                Length = Road.Length,
                HistoricalBackground = Road.HistoricalBackground,
                EconomicValue = Road.EconomicValue,
                LawDoc = Road.LawDoc,
                AcceptTransferDoc = Road.AcceptTransferDoc,
                AcceptanceDoc = Road.AcceptanceDoc,
                AuthorityAct = Road.AuthorityAct,
                RoadTypeId = Road.RoadTypeId,
                Index = Road.Index
            }).Skip(pagination.from).Take(pagination.perPage);
            switch (pagination.orderType())
            {
                case "ASC":
                    return data.OrderBy(i => i.GetType().GetProperty(pagination.sort).GetValue(i, null)).ToList();
          
                case "DESC":
                    return data.OrderByDescending(i => i.GetType().GetProperty(pagination.sort).GetValue(i, null)).ToList();
            
                default:
                    return data.OrderByDescending(i => i.Id).ToList();
            }     
            
        }

        public Task<Road> CreateAsync(RoadEditDsM data){
              return Task.Factory.StartNew(()=> { return Create(data); });
        }
        private Road Create(RoadEditDsM data)
        {   
            
            Road Model = InsertModel(data);
            _context.Road.Add(Model);
            _context.SaveChanges();
            return Model;
        }
        public Task<Road> UpdateAsync(RoadEditDsM data, int id){
            return Task.Factory.StartNew(()=> { return Update(data, id); });
        }
        private Road Update(RoadEditDsM data, int id)
        {   
            Road Model = InsertModel(data);
            Model.Id = id;
            _context.Road.Update(Model);
            _context.SaveChanges();
            return Model;
        }
        public Road InsertModel(RoadEditDsM data){
            Road Model = new Road{
                Name = data.Name,
                Value = data.Value,
                Length = data.Length,
                HistoricalBackground = data.HistoricalBackground,
                EconomicValue = data.EconomicValue,
                LawDoc = data.LawDoc,
                AcceptTransferDoc = data.AcceptTransferDoc,
                AcceptanceDoc = data.AcceptanceDoc,
                AuthorityAct = data.AuthorityAct,
                RoadTypeId = data.RoadTypeId,
                Index = data.Index
            };
            return Model;
        }
        public async Task<int> DeleteAsync(int Id)
        {
            var road = await _context.Road.SingleOrDefaultAsync(x => x.Id == Id);
            _context.Road.Remove(road);
            return await _context.SaveChangesAsync();
        }

    }
}