using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Threading.Tasks;
using FarmmapsApi;
using FarmmapsApi.Models;
using FarmmapsApi.Services;
using FarmmapsNbs.Models;
using Microsoft.Extensions.Logging;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using static FarmmapsApiSamples.Constants;

namespace FarmmapsNbs {
    public class NbsApplication : IApplication {
        private const string DownloadFolder = "Downloads";
        private const string SettingsFile = "settings.json";

        private readonly ILogger<NbsApplication> _logger;
        private readonly FarmmapsApiService _farmmapsApiService;
        private readonly NitrogenService _nitrogenService;
        private readonly GeneralService _generalService;

        private Settings _settings;

        public NbsApplication(ILogger<NbsApplication> logger, FarmmapsApiService farmmapsApiService,
            GeneralService generalService, NitrogenService nitrogenService) {
            _logger = logger;
            _farmmapsApiService = farmmapsApiService;
            _generalService = generalService;
            _nitrogenService = nitrogenService;
        }

        public async Task RunAsync() {
            var nitrogenInputJson = File.ReadAllText("NitrogenInput.json");
            List<NitrogenInput> nitrogenInputs = JsonConvert.DeserializeObject<List<NitrogenInput>>(nitrogenInputJson);

            if (!Directory.Exists(DownloadFolder))
                Directory.CreateDirectory(DownloadFolder);

            // !! this call is needed the first time an api is called with a fresh clientid and secret !!
            await _farmmapsApiService.GetCurrentUserCodeAsync();
            var roots = await _farmmapsApiService.GetCurrentUserRootsAsync();

            foreach (var input in nitrogenInputs) {
                try {
                    await Process(roots, input);
                } catch (Exception ex) {
                    _logger.LogError(ex.Message);
                }
            }
        }

        private async Task Process(List<UserRoot> roots, NitrogenInput input) {

            // !!specify if you are using an already created cropfield:
            bool useCreatedCropfield = input.UseCreatedCropfield;
            var plantingDate = input.PlantingDate;
            var FieldName = input.fieldName;
            bool StoreStatistics = input.storeSatelliteStatistics;
            var measurementDate = input.MeasurementDate;
            string settingsfile = $"Settings_{FieldName}.json";

            LoadSettings(settingsfile);

            var uploadedRoot = roots.SingleOrDefault(r => r.Name == "USER_IN");
            if (uploadedRoot == null) {
                _logger.LogError("Could not find a needed root item");
                return;
            }

            var myDriveRoot = roots.SingleOrDefault(r => r.Name == "USER_FILES");
            if (myDriveRoot == null) {
                _logger.LogError("Could not find a needed root item");
                return;
            }

            // Use already created cropfield or create new one
            Item cropfieldItem;
            if (useCreatedCropfield == false || string.IsNullOrEmpty(_settings.CropfieldItemCode)) {
                _logger.LogInformation("Creating cropfield");
                cropfieldItem = await _generalService.CreateCropfieldItemAsync(myDriveRoot.Code,
                    $"VRA NBS cropfield {input.OutputFileName}", plantingDate.Year, input.GeometryJson.ToString(Formatting.None));
                _settings.CropfieldItemCode = cropfieldItem.Code;
                SaveSettings(settingsfile);
            } else {
                _logger.LogInformation("Cropfield already exists, trying to get it");
                cropfieldItem = await _farmmapsApiService.GetItemAsync(_settings.CropfieldItemCode);
            }

            var inputItem = (Item)null;
            var geotiffItem = (Item)null;

            // If no input file is specified, use most recent satellite image
            if (string.IsNullOrEmpty(input.File)) {
                _logger.LogInformation("No specific data given, retrieving most recent satellite image");

                // check if satellite task not yet done, do here and save taskcode
                if (useCreatedCropfield == false || string.IsNullOrEmpty(_settings.SatelliteTaskCode)) {
                    var satelliteTaskCode = await _generalService.RunSatelliteTask(cropfieldItem);
                    _settings.SatelliteTaskCode = satelliteTaskCode;
                    SaveSettings(settingsfile);
                }


                // Select a particular satellite item from satelliteTask
                Item satelliteItem = await _generalService.FindSatelliteItem(cropfieldItem, _settings.SatelliteTaskCode);

                var satelliteBand = satelliteItem.Data["layers"][0]["name"];
                var satelliteStatistics = satelliteItem.Data["layers"][0]["renderer"]["band"]["statistics"];
                Console.WriteLine($"Satellite image date: {satelliteItem.DataDate}");
                //Console.WriteLine($"Satellite image statistics for band {satelliteBand}: {satelliteStatistics}");

                //Store data to csv 
                if (StoreStatistics == true) {

                    var SatelliteStatsFile = $"{DownloadFolder}/SatelliteDataStatistics_{FieldName}_{satelliteItem.DataDate.Value:yyyy-MM-dd}.csv";
                    using var w = new StreamWriter(SatelliteStatsFile);
                    {
                        foreach (var item in satelliteStatistics) {
                            var line = string.Format("{0}", item);
                            w.WriteLine(line);
                            w.Flush();
                        }
                    }
                }

                // must be wdvi[1]
                var inputType = (satelliteItem.Data["layers"] as JArray)?[1]["name"].ToString();
                if (string.IsNullOrEmpty(inputType)) {
                    _logger.LogError("Could not get the input type name from the satellite item");
                    return;
                }

                // download the geotiff
                var SatelliteImageDate = (DateTime)satelliteItem.DataDate;
                var SatelliteDate = SatelliteImageDate.ToString("yyyyMMdd");
                _logger.LogInformation("Downloading geotiff file");
                await _farmmapsApiService.DownloadItemAsync(satelliteItem.Code,
                    Path.Combine(DownloadFolder, $"nbs_inputSatelliteGeotiff_{input.OutputFileName}_{inputType}_{SatelliteDate}.zip"));

                // overwrite measurement date by date of satellite item
                measurementDate = satelliteItem.DataDate.Value;
                inputItem = satelliteItem;
            }


            // (geo)tiff input:
            else if (input.File.Contains(".tif") || input.File.Contains(".geotiff")) {
                _logger.LogInformation("input = tiff data");
                var dataPath = Path.Combine("Data", input.File);
                inputItem = await _generalService.UploadDataAsync(uploadedRoot, GEOTIFF_PROCESSED_ITEMTYPE, dataPath,
                        Path.GetFileNameWithoutExtension(input.File));

                if (geotiffItem == null) {
                    _logger.LogError("Could not find item for uploaded data");
                    return;
                }
            }

            // json/shape input
            else {
                var isGeoJson = input.File.Contains("json");
                var dataPath = Path.Combine("Data", input.File);
                var shapeItem = isGeoJson ?
                    await _generalService.UploadDataAsync(uploadedRoot, SHAPE_PROCESSED_ITEMTYPE, dataPath, Path.GetFileNameWithoutExtension(input.File), input.GeometryJson.ToString(Formatting.None)) :
                    await _generalService.UploadZipWithShapeAsync(uploadedRoot, dataPath, Path.GetFileNameWithoutExtension(input.File), input.GeometryJson.ToString(Formatting.None));

                if (shapeItem == null) {
                    _logger.LogError("Could not find item for uploaded data");
                    return;
                }
                inputItem = shapeItem;
                ////convert shape to geotiff, not necessary anymore. However can still be done
                //_logger.LogInformation($"Converting shape to geotiff");
                //geotiffItem = await _generalService.ShapeToGeotiff(shapeItem, 1, input.InputLayerName);
                //if (geotiffItem == null)
                //{
                //    _logger.LogError("Something went wrong with shape to geotiff transformation");
                //    return;
                //}

                //_logger.LogInformation("Downloading geotiff file");
                //await _farmmapsApiService.DownloadItemAsync(geotiffItem.Code,
                //    Path.Combine(DownloadFolder, $"{input.OutputFileName}.input_geotiff.zip"));
                //inputItem = geotiffItem;
                ////End shape to geotiff transformation
            }

            _logger.LogInformation($"Calculating targetN with targetYield: {input.TargetYield}");
            var targetNItem = await _nitrogenService.CreateTargetNItem(cropfieldItem);
            var targetNData = await _nitrogenService.CalculateTargetN(cropfieldItem, targetNItem, plantingDate,
                measurementDate, input.PotatoPurposeType, input.TargetYield);

            if (targetNData == null) {
                _logger.LogError("Something went wrong with TargetN calculation");
                return;
            }

            _logger.LogInformation($"TargetN: {targetNData.TargetN}");

            var targetNDataPath = Path.Combine(DownloadFolder, $"{input.OutputFileName}.targetn.json");

            await File.WriteAllTextAsync(targetNDataPath, JsonConvert.SerializeObject(targetNData, Formatting.Indented));

            _logger.LogInformation("Calculating uptake map");
            var uptakeMapItem =
                await _nitrogenService.CalculateUptakeMap(cropfieldItem, inputItem, plantingDate,
                    measurementDate, input.InputVariable, input.InputLayerName);
            if (uptakeMapItem == null) {
                _logger.LogError("Something went wrong with creating the uptakeMap");
                return;
            }

            _logger.LogInformation("Downloading uptake map");
            await _farmmapsApiService.DownloadItemAsync(uptakeMapItem.Code,
                Path.Combine(DownloadFolder, $"{input.OutputFileName}.uptake.zip"));
            _logger.LogInformation("UptakeMap downloaded");

            _logger.LogInformation("Calculating application map");
            var applianceMapItem =
                await _nitrogenService.CalculateApplicationMap(cropfieldItem, inputItem, plantingDate,
                    measurementDate, input.InputVariable, targetNData.TargetN, input.InputLayerName);

            if (applianceMapItem == null) {
                _logger.LogError("Something went wrong with creating the applicationMap");
                return;
            }
            _logger.LogInformation("Downloading application map");
            await _farmmapsApiService.DownloadItemAsync(applianceMapItem.Code,
                Path.Combine(DownloadFolder, $"{input.OutputFileName}.application.zip"));
            _logger.LogInformation("Application map can be found in {0}", Path.Combine(DownloadFolder, $"{input.OutputFileName}.application.zip"));

            //transforming tiff to shape
            var tiffItem = applianceMapItem;

            if (tiffItem == null) {
                _logger.LogError("Could not find item for uploaded data");
                return;
            }

            //ApplicationMap (GEOTIFF) To Taskmap
            if (input.GenerateTaskmap) {
                //GEOTIFF TO Taskmap
                _logger.LogInformation($"Converting geotiff to taskmap");

                var taskmap = (Item)null;
                if (input.OutputType == "isoxml") {

                    if (input.DdiCode == null) {
                        _logger.LogInformation("DDi not given. Using expected identifiers");
                        input.DdiCode = input.DdiCode = "0006";

                    }
                    taskmap = await _generalService.CreateTaskmap(cropfieldItem: cropfieldItem, tiffItem: applianceMapItem, outputType: input.OutputType, cellWidth: input.CellWidth,
                        cellHeight: input.CellHeight, startPoint: input.StartPoint.ToString(Formatting.None), inputLayerName: input.InputLayerName, ddiCode: input.DdiCode, centered: input.Centered,
                        endPoint: input.EndPoint.ToString(Formatting.None), angle: input.Angle, precision: input.Precision,
                        cropTypeName: null, costumerName: null, ProductGroupName: null, productName: null, resolution: null, unitScale: null, maximumClasses: input.MaximumClasses);

                } else {
                    taskmap = await _generalService.CreateTaskmap(cropfieldItem: cropfieldItem, tiffItem: applianceMapItem, outputType: input.OutputType, cellWidth: input.CellWidth,
                        cellHeight: input.CellHeight, startPoint: input.StartPoint.ToString(Formatting.None), inputLayerName: input.InputLayerName, centered: input.Centered,
                        endPoint: input.EndPoint.ToString(Formatting.None), angle: input.Angle, precision: input.Precision, maximumClasses: input.MaximumClasses);
                }



                if (taskmap == null) {
                    _logger.LogError("Something went wrong with geotiff to taskmap transformation");
                    return;
                }

                _logger.LogInformation("Downloading taskmap");
                await _farmmapsApiService.DownloadItemAsync(taskmap.Code,
                    Path.Combine(DownloadFolder, $"{input.OutputFileName}.taskmap.zip"));
            }




        }

        // Functions to save previously created cropfields
        private void LoadSettings(string file) {
            if (File.Exists(file)) {
                var jsonText = File.ReadAllText(file);
                _settings = JsonConvert.DeserializeObject<Settings>(jsonText);
            } else {
                _settings = new Settings();
            }
        }

        private void SaveSettings(string file) {
            if (_settings == null)
                return;

            var json = JsonConvert.SerializeObject(_settings);
            File.WriteAllText(file, json);
        }
        private void SaveInfo(string file) {
            if (_settings == null)
                return;

            var json = JsonConvert.SerializeObject(_settings);
            File.WriteAllText(file, json);

        }

    }
}