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;
using MapsModels.ViewModels;

namespace MapsDb.DataService
{
    public class Test {
        public int Id {get; set;}
        public IEnumerable<Node> Points {get; set;}
    }
    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();
        }

        public List<WayLook> GetRelationAsync(int Id)
        {
            IQueryable<Way> ways = _context.Way.Where(x => x.WayToRelation.Any(y => y.Relation.RelationToRoad.Any(z => z.RoadId == Id)));
            List<NodeUnsortLook> list = (from way in ways
                join nodeToWay in _context.NodeToWay on way.Id equals nodeToWay.WayId
                join node in _context.Node on nodeToWay.NodeId equals node.Id
                orderby way.Id, nodeToWay.Index
                select new NodeUnsortLook {
                    NodeId = node.Id,
                    Lat = node.Lat, 
                    Lon = node.Lon,
                    Index = nodeToWay.Index,
                    WayId = way.Id  
                }).ToList();
            List<WayLook> result = new List<WayLook>();
            foreach (NodeUnsortLook nodeUnsort in list) {
                WayLook item = result.SingleOrDefault(x => x.Id == nodeUnsort.WayId);
                if (item == null) {
                    item = new WayLook() {
                        Id = nodeUnsort.WayId,
                        Nodes = new List<NodeLook>()
                    };
                    result.Add(item);
                }
                item.Nodes.Add(new NodeLook() {
                    Id = nodeUnsort.NodeId,
                    Index = nodeUnsort.Index,
                    Lat = nodeUnsort.Lat,
                    Lon = nodeUnsort.Lon
                });
            }
            return result;
        }

        public RoadVm GetByWay(int Id)
        {
            RoadVm road = _context.Road.Where(x => x.RelationToRoad.Any(y => y.Relation.WayToRelation.Any(z => z.WayId == Id))).Include(t => t.RoadType).Select(r => new RoadVm{
                Id = r.Id,
                Name = r.Name,
                Value = r.Value,
                Length = r.Length,
                HistoricalBackground = r.HistoricalBackground,
                EconomicValue = r.EconomicValue,
                LawDoc = r.LawDoc,
                AcceptTransferDoc = r.AcceptTransferDoc,
                AcceptanceDoc = r.AcceptanceDoc,
                AuthorityAct = r.AuthorityAct,
                RoadType = r.RoadType.Value,
                Index = r.Index
            }).FirstOrDefault();
            return road;
        }
        public RoadVm GetByNode(int Id)
        {
            RoadVm road = _context.Road.Where(x => x.RelationToRoad.Any(y => y.Relation.WayToRelation.Any(z => z.Way.NodeToWay.Any(a => a.NodeId == Id)))).Include(t => t.RoadType).Select(r => new RoadVm{
                Id = r.Id,
                Name = r.Name,
                Value = r.Value,
                Length = r.Length,
                HistoricalBackground = r.HistoricalBackground,
                EconomicValue = r.EconomicValue,
                LawDoc = r.LawDoc,
                AcceptTransferDoc = r.AcceptTransferDoc,
                AcceptanceDoc = r.AcceptanceDoc,
                AuthorityAct = r.AuthorityAct,
                RoadType = r.RoadType.Value,
                Index = r.Index
            }).FirstOrDefault();
            return road;
        }
    }
}