using System.Text;
using Castle.Core.Internal;
using Newtonsoft.Json;
using Trucks.Data.Models;
using Trucks.Data.Models.Enums;
using Trucks.DataProcessor.ImportDto;

namespace Trucks.DataProcessor
{
    using System;
    using System.Collections.Generic;
    using System.ComponentModel.DataAnnotations;
    using System.Linq;

    using Data;

    public class Deserializer
    {
        private const string ErrorMessage = "Invalid data!";

        private const string SuccessfullyImportedDespatcher
            = "Successfully imported despatcher - {0} with {1} trucks.";

        private const string SuccessfullyImportedClient
            = "Successfully imported client - {0} with {1} trucks.";

        public static string ImportDespatcher(TrucksContext context, string xmlString)
        {
            var sb = new StringBuilder();

            var despatcherDto = XmlConverter.Deserializer<ImportDespatchersXML>(xmlString, "Despatchers");

            var valiDespatchers = new List<Despatcher>();


            foreach (var dDto in despatcherDto)
            {

                if (!IsValid(dDto))
                {
                    sb.AppendLine(ErrorMessage);
                    continue;
                }

                if (dDto.Position.IsNullOrEmpty())
                {
                    sb.AppendLine(ErrorMessage);
                    continue;
                }

                var trucks = new List<Truck>();


                foreach (var tDto in dDto.Trucks)
                {

                    if (!IsValid(tDto))
                    {
                        sb.AppendLine(ErrorMessage);
                        continue;
                    }


                    if (tDto.VinNumber.IsNullOrEmpty())
                    {
                        sb.AppendLine(ErrorMessage);
                        continue;
                    }


                    trucks.Add(new Truck()
                    {
                        RegistrationNumber = tDto.RegistrationNumber,
                        VinNumber = tDto.VinNumber,
                        TankCapacity = tDto.TankCapacity,
                        CargoCapacity = tDto.CargoCapacity,
                        CategoryType = (CategoryType)tDto.CategoryType,
                        MakeType = (MakeType)tDto.MakeType
                    });


                }

                Despatcher despatcher = new Despatcher()
                {
                    Name = dDto.Name,
                    Position = dDto.Position,
                    Trucks = trucks
                };

                valiDespatchers.Add(despatcher);

                sb.AppendLine(string.Format(SuccessfullyImportedDespatcher, despatcher.Name, trucks.Count()));
            }

            context.Despatchers.AddRange(valiDespatchers);
            context.SaveChanges();

            return sb.ToString().TrimEnd();



        }
        public static string ImportClient(TrucksContext context, string jsonString)
        {
            var sb = new StringBuilder();

            ImportCleintsDTOJson[] clientsDto = JsonConvert.DeserializeObject<ImportCleintsDTOJson[]>(jsonString);

            List<Client> validClients = new List<Client>();

            foreach (var cDTO in clientsDto)
            {

                if (!IsValid(cDTO))
                {
                    sb.AppendLine(ErrorMessage);
                    continue;
                }

                if (cDTO.Type == "usual")
                {
                    sb.AppendLine(ErrorMessage);
                    continue;
                }

                Client client = new Client()
                {
                    Name = cDTO.Name,
                    Nationality = cDTO.Nationality,
                    Type = cDTO.Type
                };


                foreach (var tDTO in cDTO.Trucks.Distinct())
                {

                    Truck truck = context.Trucks.FirstOrDefault(f => f.Id == tDTO);

                    if (truck == null)
                    {
                        sb.AppendLine(ErrorMessage);
                        continue;
                    }

                    if (!IsValid(tDTO))
                    {
                        sb.AppendLine(ErrorMessage);
                        continue;
                    }

                    ClientTruck clientTruck = new ClientTruck()
                    {
                        Client = client,
                        Truck = truck
                    };

                    client.ClientsTrucks.Add(clientTruck);

                }

                validClients.Add(client);
                sb.AppendLine(string.Format(SuccessfullyImportedClient, client.Name, client.ClientsTrucks.Count()));

            }

            context.Clients.AddRange(validClients);
            context.SaveChanges();
            return sb.ToString().TrimEnd();
        }

        private static bool IsValid(object dto)
        {
            var validationContext = new ValidationContext(dto);
            var validationResult = new List<ValidationResult>();

            return Validator.TryValidateObject(dto, validationContext, validationResult, true);
        }
    }
}