using AsbCloudApp.Data.Trajectory;
using AsbCloudApp.Exceptions;
using AsbCloudApp.Repositories;
using AsbCloudApp.Requests;
using AsbCloudDb.Model;
using AsbCloudDb.Model.WITS;
using Microsoft.EntityFrameworkCore;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using AsbCloudApp.Services;

namespace AsbCloudInfrastructure.Repository
{
    public class TrajectoryNnbRepository : ITrajectoryNnbRepository
    {
        private readonly IAsbCloudDbContext db;
        private readonly IWellService wellService;
        
        public TrajectoryNnbRepository(IAsbCloudDbContext db,
            IWellService wellService)
        {
            this.db = db;
            this.wellService = wellService;
        }

        private IQueryable<Record7> BuildQuery(TrajectoryRequest request)
        {
            var well = db.Wells.SingleOrDefault(w => w.Id == request.IdWell);
            var timezone = wellService.GetTimezone(request.IdWell);

            if (well is null)
                throw new ArgumentInvalidException($"Скважина с Id: {request.IdWell} не найдена", nameof(request.IdWell));

            var query = db.Record7.Where(r => r.IdTelemetry == well.IdTelemetry)
                .Where(x => x.IdTelemetry == well.IdTelemetry);

            if (request.GeDate.HasValue)
            {
                var geDate = request.GeDate.Value.ToUtcDateTimeOffset(timezone.Hours);
                query = query.Where(r => r.DateTime >= geDate);   
            }

            if (request.LeDate.HasValue)
            {
                var leDate = request.LeDate.Value.ToUtcDateTimeOffset(timezone.Hours);
                query = query.Where(r => r.DateTime <= leDate);   
            }

            return query.OrderBy(e => e.Deptsvym);
        }

        public async Task<IEnumerable<TrajectoryGeoFactDto>> GetAsync(int idWell, CancellationToken token)
        {
            var request = new TrajectoryRequest()
            {
                IdWell = idWell,
            };
            var result = await GetByRequestAsync(request, token);
            return result;
        }

        public async Task<IEnumerable<TrajectoryGeoFactDto>> GetByRequestAsync(TrajectoryRequest request, CancellationToken token)
        {
            var entities = (await BuildQuery(request)
           .Where(coord => coord.Deptsvym.HasValue &&
                           coord.Svyinc.HasValue &&
                           coord.Svyazc.HasValue)
           .AsNoTracking()
           .ToArrayAsync(token));

            var result = entities
                .Select(coord => new TrajectoryGeoFactDto
                {
                    IdWell = request.IdWell,
                    AzimuthMagnetic = coord.Svymtf,
                    VerticalDepth = coord.Deptsvyv,
                    WellboreDepth = coord.Deptsvym!.Value,
                    ZenithAngle = coord.Svyinc!.Value,
                    AzimuthGeo = coord.Svyazc!.Value
                })
                .ToArray();

            return result;
        }
    }
}