using System;
using System.Collections.Generic;
using System.Data;
using System.IO;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Web.Http;
using System.Web.Http.ModelBinding;
using Kendo.Mvc.Extensions;
using Kendo.Mvc.UI;
using Kreta.BusinessLogic.Exceptions;
using Kreta.BusinessLogic.Helpers;
using Kreta.BusinessLogic.Helpers.SystemSettings;
using Kreta.BusinessLogic.Logic;
using Kreta.Client.Eugyintezes.Configuration;
using Kreta.Core;
using Kreta.Core.Exceptions;
using Kreta.Core.FileService;
using Kreta.Enums;
using Kreta.Framework.Entities;
using Kreta.Framework.Util;
using Kreta.Resources;
using Kreta.Web.Areas.Intezmeny.Logic;
using Kreta.Web.Areas.Intezmeny.Models;
using Kreta.Web.Helpers;
using Kreta.Web.Helpers.Error;
using Kreta.Web.Helpers.Grid;
using Kreta.Web.Security;
using Newtonsoft.Json;

namespace Kreta.Web.Areas.Intezmeny.ApiControllers
{
    public class BaseTeremApiController : ApiController
    {
        protected readonly IFileService FileService;
        protected readonly IEugyintezesClientConfiguration EugyintezesClientConfiguration;

        public BaseTeremApiController(IFileService fileService, IEugyintezesClientConfiguration eugyintezesClientConfiguration)
        {
            FileService = fileService;
            EugyintezesClientConfiguration = eugyintezesClientConfiguration;
        }

        public DataSourceResult GetTeremGrid(string data, DataSourceRequest request)
        {
            var (gridParameter, modelList, _) = GetGridData(data, request);

            return modelList.ToDataSourceResult(gridParameter);
        }

        public HttpResponseMessage GetExport(string data, DataSourceRequest request)
        {
            try
            {
                var (gridParameter, modelList, exportAttributeName) = GetGridData(data, request);

                modelList = modelList.SortingAndPaging(gridParameter.OrderDictionary);

                var simpleExportColumnCos = SimpleExportLogic.GetSimpleExportColumnCos<TeremGridModel>(exportAttributeName);

                var memoryStream = SimpleExportLogic.GetExport(IntezmenyResource.ExportSheetName, simpleExportColumnCos, modelList, ClaimData.SelectedTanevID.Value);

                return HttpResponseExtensions.GetFileHttpResponse(memoryStream.ToArray(), $"{IntezmenyResource.Termek_Export}_{DateTime.Now:yyyy_MM_dd}.xlsx");
            }
            catch (Exception ex)
            {
                throw new StatusError(HttpStatusCode.BadRequest, ErrorResource.HibaTortentAFajlExportalasaKozben) { UnHandledException = ex };
            }
        }

        private (GridParameters gridParameter, List<TeremGridModel> modelList, string exportAttributeName) GetGridData(string data, DataSourceRequest request)
        {
            var connection = ConnectionTypeExtensions.GetSessionConnectionType();
            var model = JsonConvert.DeserializeObject<TeremSearchModel>(data);

            var gridParameter = Converter.GridParameter(request);

            int? felhasznaloSzervezetId = null;
            if (ClaimData.FelhasznaloSzerepkor != SzerepkorTipusEnum.Adminisztrator)
            {
                felhasznaloSzervezetId = new SzervezetHelper(connection).GetAlkalmazottSzervezetId(ClaimData.FelhasznaloId);
                model.SzervezetId = felhasznaloSzervezetId;
            }
            var coList = new TeremHelper(connection).GetTeremCoList(model.ConvertToCo(), ClaimData.IsAdministrator, felhasznaloSzervezetId);
            var modelList = coList.Select(x => new TeremGridModel(x)).ToList();
            modelList = modelList.SortingAndPaging(gridParameter.OrderDictionary);

            var exportAttributeName = model.IsFromSzervezet ? TeremGridModel.HelyszinExportAttributeId : TeremGridModel.TeremExportAttributeId;

            return (gridParameter, modelList, exportAttributeName);
        }

        public TeremModel GetTeremBaseProperties(int teremID)
        {
            return TeremLogic.GetTeremBaseProperties(teremID);
        }

        public DataSourceResult GetTeremOrarendiOrai(string teremID, [ModelBinder(typeof(ModelBinder.DataSourceRequestModelBinder))] DataSourceRequest request)
        {
            var orarendiOraHelper = new OrarendiOraHelper(ConnectionTypeExtensions.GetSessionConnectionType())
            {
                GridParameters = Converter.GridParameter(request)
            };

            DataSet orak = orarendiOraHelper.GetOrarendiOrakForTerem(int.Parse(teremID));

            return orak.ToDataSourceResult();
        }

        [HttpPost]
        [ApiValidateAjaxAntiForgeryToken]
        public HttpResponseMessage SaveModifiedOrNewTerem(TeremModel teremModel)
        {
            try
            {
                var teremHelper = new TeremHelper(ConnectionTypeExtensions.GetSessionConnectionType());
                var kapcsolodoOraTipusok = teremHelper.GetTeremKapcsolodoOraTipusok(teremModel.TeremId);
                TeremModel.ValidateModel(teremModel, kapcsolodoOraTipusok, ModelState);

                if (ModelState.IsValid)
                {
                    var terem = TeremLogic.GetTeremBaseProperties(teremModel.TeremId);
                    var teremBerbeadhatoAlapertek = terem.TeremBerbeadasModel.Berbeadhato;

                    var teremCO = TeremModel.ConvertModelToCO(teremModel);

                    var teremId = 0;

                    if (teremModel.TeremBerbeadasModel.Berbeadhato)
                    {
                        if (teremModel.TeremBerbeadasModel.PictureList.Count > 0)
                        {
                            var kepInfo = new FileInfo(teremModel.TeremBerbeadasModel.PictureList.Select(x => x.Name).First());

                            teremCO.KepUtvonal = teremHelper.SaveTeremFiles(FileService, teremModel.TeremBerbeadasModel.PictureList.Select(x => x.ContentAsBase64EncodedString)).First();
                            teremCO.KepNev = Path.GetFileNameWithoutExtension(kepInfo.Name);
                            teremCO.KepKiterjesztes = kepInfo.Extension.Replace(".", string.Empty);
                        }

                        if (teremModel.TeremBerbeadasModel.Document != null
                            && teremModel.TeremBerbeadasModel.Document.Count > 0)
                        {
                            var dokumentumInfo = new FileInfo(teremModel.TeremBerbeadasModel.Document.Select(x => x.Name).First());

                            teremCO.DokumentumUtvonal = teremHelper.SaveTeremFiles(FileService, teremModel.TeremBerbeadasModel.Document.Select(x => x.ContentAsBase64EncodedString)).First();
                            teremCO.DokumentumNev = Path.GetFileNameWithoutExtension(dokumentumInfo.Name);
                            teremCO.DokumentumKiterjesztes = dokumentumInfo.Extension.Replace(".", string.Empty);
                        }
                    }

                    if (teremModel.TeremId > 0)
                    {
                        teremHelper.UpdateTerem(teremCO);
                    }
                    else
                    {
                        teremId = teremHelper.InsertTerem(teremCO);
                    }

                    if (teremModel.TeremBerbeadasModel.Berbeadhato && teremModel.TeremBerbeadasModel.TeremBerbeadasIdopontokListModel?.Count > 0)
                    {
                        //nyakatekert
                        teremCO.TeremBerbeadasIdopontokCOList.ForEach(item =>
                        {
                            if (item.TeremElerhetosegId.HasValue)
                            {
                                teremHelper.UpdateTeremElerhetoseg(item);
                            }
                            else
                            {
                                teremHelper.InsertTeremElerhetoseg(item, teremCO.TeremId ?? teremId);
                            }
                        });
                    }

                    // Ha bérbeadható, vagy most váltott nem bérbeadható státuszra
                    if (teremModel.TeremBerbeadasModel.Berbeadhato || teremBerbeadhatoAlapertek)
                    {
                        TeremLogic.EugyErtesitesTeremBerbeadhatoStatuszValtozasrol(EugyintezesClientConfiguration);
                    }

                    return new HttpResponseMessage(HttpStatusCode.OK);
                }

                return Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState);
            }
            catch (SDA.DataProvider.UniqueKeyViolationException)
            {
                throw new StatusError(HttpStatusCode.BadRequest, ErrorResource.MarLetezikTeremIlyenNevvel);
            }
            catch (EntityDeleteFailedException edfex)
            {
                throw new StatusError(HttpStatusCode.Forbidden, edfex.Message.Replace("'CONNECTIONS'", edfex.ConnectionErrorMessage));
            }
        }

        [HttpPost]
        [ApiValidateAjaxAntiForgeryToken]
        public IHttpActionResult ValidateSaveModifiedOrNewTerem(TeremModModel model)
        {
            var systemSettingsHelper = new SystemSettingsHelper(ConnectionTypeExtensions.GetSessionConnectionType());
            var naplozasTeremBefogadokepessegSystemSetting = systemSettingsHelper.GetSystemSettingValue<bool>(RendszerBeallitasTipusEnum.Naplozas_terem_befogadokepesseg);

            var kapacitastTullepettTermekFigyelmeztetoUzenet = string.Empty;

            if (!string.IsNullOrWhiteSpace(model.TeremIDArray) && model.Kapacitas.HasValue && naplozasTeremBefogadokepessegSystemSetting)
            {
                var h = new TeremHelper(ConnectionTypeExtensions.GetSessionConnectionType());
                kapacitastTullepettTermekFigyelmeztetoUzenet = h.ValidateTeremBefogadokepesseg(tervezettKapacitas: model.Kapacitas, teremIdArrayString: model.TeremIDArray);
            }
            if (!string.IsNullOrWhiteSpace(kapacitastTullepettTermekFigyelmeztetoUzenet))
            {
                return Json(new { Valid = false, Text = kapacitastTullepettTermekFigyelmeztetoUzenet });
            }

            return Json(new { Valid = true, Text = "" });
        }

        [HttpPost]
        [ApiValidateAjaxAntiForgeryToken]
        public HttpResponseMessage SaveModTerem(TeremModModel model)
        {
            if (ModelState.IsValid)
            {
                if (model.VizsgaKapacitas > model.Kapacitas)
                {
                    throw new StatusError(HttpStatusCode.BadRequest, ErrorResource.AVizsgaBefogadokepessegNemLehetNagyobbMintABefogadokepesseg);
                }

                var co = TeremModModel.ConvertModelToCO(model);
                var h = new TeremHelper(ConnectionTypeExtensions.GetSessionConnectionType());

                string[] teremIDArray;
                var errorMsgs = new List<(string errorMsg, HttpStatusCode errorStatusCode)>();

                if (string.IsNullOrWhiteSpace(model.TeremIDArray))
                {
                    teremIDArray = new string[] { co.ID.ToString() };
                }
                else
                {
                    teremIDArray = model.TeremIDArray.Split(',');
                }
                foreach (var item in teremIDArray)
                {
                    try
                    {
                        co.ID = int.Parse(item);
                        h.TeremTobbesModify(co);
                    }
                    catch (BlException e)
                    {
                        errorMsgs.Add((e.Message, HttpStatusCode.BadRequest));
                        continue;
                    }
                    catch (EntityDeleteFailedException edfex)
                    {
                        errorMsgs.Add((edfex.Message.Replace("'CONNECTIONS'", edfex.ConnectionErrorMessage), HttpStatusCode.Forbidden));
                        continue;
                    }
                }
                if (errorMsgs.Count == 0)
                {
                    return new HttpResponseMessage(HttpStatusCode.OK);
                }
                var usedErrorStatusCode = errorMsgs.GroupBy(x => x.errorStatusCode).Select(group => new { Key = group.Key, Count = group.Count() }).OrderBy(x => x.Count).First().Key;
                throw new StatusError(usedErrorStatusCode, string.Join(Environment.NewLine, errorMsgs.Select(x => x.errorMsg)));
            }

            return Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState);
        }

        public TeremModModel GetTeremBasePropertiesMod(int teremID)
            => TeremModModel.ConvertCOToModel(new TeremHelper(ConnectionTypeExtensions.GetSessionConnectionType()).GetTeremCo(teremID));

        [HttpPost]
        [ApiValidateAjaxAntiForgeryToken]
        public HttpResponseMessage DeleteTerem([FromBody] int TeremId)
        {
            try
            {
                var h = new TeremHelper(ConnectionTypeExtensions.GetSessionConnectionType());

                h.DeleteTerem(TeremId);
                return new HttpResponseMessage(HttpStatusCode.OK);
            }
            catch (CannotBeDeletedException ex)
            {
                throw new StatusError(HttpStatusCode.BadRequest, ex.Message);
            }
            catch (EntityDeleteFailedException ex)
            {
                var uzenet = string.Format(ErrorResource.Az0NemTorolhetoMertEgyVagyTobbKapcsolodasaVanKapcsolatok1, IntezmenyResource.Terem, ex.ConnectionErrorMessage);
                throw new StatusError(HttpStatusCode.BadRequest, uzenet);
            }
        }

        [HttpPost]
        [ApiValidateAjaxAntiForgeryToken]
        public IHttpActionResult DeleteSelectedTerem(List<int> idList)
        {
            var h = new TeremHelper(ConnectionTypeExtensions.GetSessionConnectionType());
            string errorMsg = string.Empty, entityName = string.Empty;
            var counter = 0;

            foreach (var id in idList)
            {
                try
                {
                    h.DeleteTerem(id);
                    counter++;
                }
                catch (CannotBeDeletedException ex)
                {
                    errorMsg += $"{ex.Message}{Environment.NewLine}";
                    continue;
                }
                catch (EntityDeleteFailedException ex)
                {
                    var teremNev = h.GetTeremNev(id);
                    var errorMessage = string.Format(ErrorResource.NemTorolhetoKapcsolatMiatt, teremNev, ex.ConnectionErrorMessage);

                    errorMsg += $"{errorMessage}{Environment.NewLine}{Environment.NewLine}";
                    continue;
                }
            }

            if (string.IsNullOrWhiteSpace(errorMsg))
            {
                return Json(new { Message = string.Format(ErrorResource.NSorTorlesSikeres, counter) });
            }

            if (counter > 0)
            {
                errorMsg += Environment.NewLine + string.Format(ErrorResource.NSorTorlesSikeres, counter);
            }
            throw new StatusError(HttpStatusCode.BadRequest, errorMsg);
        }

    }
}