using AutoMapper;
using gehGassi.Core.Interfaces;
using gehGassi.Core.Services;
using gehGassi.Dto;
using gehGassi.Dto.Common;
using gehGassi.Dto.Listings;
using gehGassi.Web.Helper;
using Microsoft.AspNetCore.Authentication.JwtBearer;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;
using System.Collections.Generic;
using System.Threading.Tasks;
using gehGassi.Dto.Advertisements;
using Asp.Versioning;

namespace gehGassi.Web.Controllers.Api
{
    /// <summary>
    /// Controller der Zugriff auf Werbungen via API ermöglicht
    /// </summary>
    [Authorize(AuthenticationSchemes = JwtBearerDefaults.AuthenticationScheme)]
    [ApiController]
    [ApiVersion(1)]
    [Route("api/advertisements")]
    [Route("api/v{v:apiVersion}/advertisements")]
    public class ApiAdvertisementsController : ApiBaseController
    {
        private readonly ILogger<ApiAdvertisementsController> _logger;
        private readonly IGeoLocationService _geoLocationService;
        private readonly IAdvertisementService _advertisementService;
        private readonly IAdvertisementCategoryService _advertisementCategoryService;

        /// <summary>
        /// Erstellt eine Instanz
        /// </summary>
        /// <param name="mapper">Instanz eines IMapper</param>
        /// <param name="logger">Instanz eines ILogger</param>
        /// <param name="localizationOptions">Instanz von LocalizationOptions</param>
        /// <param name="appUserService">Instanz eines IDogOwnerService</param>
        /// <param name="geoLocationService">Instanz eines IGeoLocationService</param>
        /// <param name="advertisementService">Instanz eines IAdvertisementService</param>
        /// <param name="advertisementCategoryService">Instanz eines IAdvertisementCategoryService</param>
        public ApiAdvertisementsController(IMapper mapper, ILogger<ApiAdvertisementsController> logger, IOptions<LocalizationOptions> localizationOptions, IAppUserService appUserService,
            IGeoLocationService geoLocationService, IAdvertisementService advertisementService, IAdvertisementCategoryService advertisementCategoryService) : base(mapper, localizationOptions, appUserService)
        {
            _logger = logger;
            _geoLocationService = geoLocationService;
            _advertisementService = advertisementService;
            _advertisementCategoryService = advertisementCategoryService;
        }

        /// <summary>
        /// Gibt eine Liste von Werbungen zurück, welche bald ablaufen und basierend auf der Geo-einschränkung zur Verfügung stehen
        /// </summary>
        /// <param name="model">Abfragemodel</param>
        /// <returns>HTTP 200 wenn erfolgreich</returns>
        [Route("GetAdvertisementsNearEnd")]
        [HttpPost]
        public async Task<IActionResult> GetAdvertisementsNearEnd(QueryDto model)
        {
            var clientOffset = GetClientDateOffset();

            if (User?.Identity != null && User.Identity.IsAuthenticated)
            {
                var response = new ListResponseDto<AdvertisementDto>();

                //Geodaten holen.
                //Entweder wurde lat und lng geliefert, oder wir müssen über den benutzer und den app-mode entscheiden
                var (country, state) = await GetGeoDataAsync(model);

                var queryResult = await _advertisementService.GetNearEndForAppAsync(country, state, model.Location.Lat.Value, model.Location.Lng.Value, model.Language, LocalizationOptions.Value.DefaultCulture, model.Skip, model.Take);

                response.Total = queryResult.total;

                var dtoList = Mapper.Map<List<AdvertisementDto>>(queryResult.list);
                var baseAddress = GetBaseAddress();
                foreach (var dtoItem in dtoList)
                {
                    if(!string.IsNullOrWhiteSpace(dtoItem.Image))
                        dtoItem.Image = $"{baseAddress}/file/documents/thumbnails/{400}/{dtoItem.Image}";
                    if (!string.IsNullOrWhiteSpace(dtoItem.Image2))
                        dtoItem.Image2 = $"{baseAddress}/file/documents/thumbnails/{400}/{dtoItem.Image2}";
                    if (!string.IsNullOrWhiteSpace(dtoItem.ImageLanguage))
                        dtoItem.ImageLanguage = $"{baseAddress}/file/documents/thumbnails/{400}/{dtoItem.ImageLanguage}";
                    if (!string.IsNullOrWhiteSpace(dtoItem.Image2Language))
                        dtoItem.Image2Language = $"{baseAddress}/file/documents/thumbnails/{400}/{dtoItem.Image2Language}";
                }

                response.List = dtoList;
                response.Take = model.Take;
                response.Skip = model.Skip;

                return Ok(response);

            }
            return NotFound(CommunicationErrors.Common_NotFound);
        }

        /// <summary>
        /// Gibt eine Werbung zurück.
        /// Diese muss laufen, darf nicht gelöscht sein und das Enddatum darf nicht erreicht sein
        /// </summary>
        /// <param name="id">Id der gesuchten Werbung</param>
        /// <param name="language">Gewünschte Sprache</param>
        /// <returns>HTTP 200 OK wenn erfolgreich</returns>
        [Route("GetRunningAdvertisement")]
        [HttpGet]
        public async Task<IActionResult> GetRunningAdvertisement(string id, string language)
        {
            var clientOffset = GetClientDateOffset();
            if (User?.Identity != null && User.Identity.IsAuthenticated)
            {
                var advertisement = await _advertisementService.GetRunningWithNamesAsync(id, language, LocalizationOptions.Value.DefaultCulture);
                if (advertisement != null)
                {
                    var dto = Mapper.Map<AdvertisementDto>(advertisement);
                    var baseAddress = GetBaseAddress();
                    if (!string.IsNullOrWhiteSpace(dto.Image))
                        dto.Image = $"{baseAddress}/file/documents/thumbnails/{400}/{dto.Image}";
                    if (!string.IsNullOrWhiteSpace(dto.Image2))
                        dto.Image2 = $"{baseAddress}/file/documents/thumbnails/{400}/{dto.Image2}";
                    if (!string.IsNullOrWhiteSpace(dto.ImageLanguage))
                        dto.ImageLanguage = $"{baseAddress}/file/documents/thumbnails/{400}/{dto.ImageLanguage}";
                    if (!string.IsNullOrWhiteSpace(dto.Image2Language))
                        dto.Image2Language = $"{baseAddress}/file/documents/thumbnails/{400}/{dto.Image2Language}";

                    return Ok(dto);
                }
            }
            return NotFound(CommunicationErrors.Common_NotFound);
        }

        /// <summary>
        /// Gibt die Liste der Werbungskategorien zurück
        /// Diese müssen den Status ONLINE haben
        /// </summary>
        /// <param name="language">Gewünschte Sprache</param>
        /// <returns>HTTP 200 OK wenn erfolgreich</returns>
        [Route("GetCategoriesOnline")]
        [HttpGet]
        public async Task<IActionResult> GetCategoriesOnline(string language)
        {
            var clientOffset = GetClientDateOffset();
            if (User?.Identity != null && User.Identity.IsAuthenticated)
            {
                var categories = await _advertisementCategoryService.GetOnlineWithNamesAsync(language, LocalizationOptions.Value.DefaultCulture);
                if (categories != null)
                {
                    var dtoList = Mapper.Map<List<AdvertisementCategoryDto>>(categories);
                    var baseAddress = GetBaseAddress();
                    foreach (var dtoItem in dtoList)
                    {
                        if (!string.IsNullOrWhiteSpace(dtoItem.Image))
                            dtoItem.Image = $"{baseAddress}/file/documents/thumbnails/{400}/{dtoItem.Image}";
                        if (!string.IsNullOrWhiteSpace(dtoItem.ImageLanguage))
                            dtoItem.ImageLanguage = $"{baseAddress}/file/documents/thumbnails/{400}/{dtoItem.ImageLanguage}";
                    }
                    return Ok(dtoList);
                }
            }
            return NotFound(CommunicationErrors.Common_NotFound);
        }

        /// <summary>
        /// Gibt eine Liste von Werbungen in einer Kategorie zurück
        /// </summary>
        /// <param name="model">Abfragemodel</param>
        /// <returns>HTTP 200 wenn erfolgreich</returns>
        [Route("GetAdvertisementsByCategory")]
        [HttpPost]
        public async Task<IActionResult> GetAdvertisementsByCategory(AdvertisementQueryDto model)
        {
            var clientOffset = GetClientDateOffset();

            if (User?.Identity != null && User.Identity.IsAuthenticated)
            {
                var response = new ListResponseDto<AdvertisementDto>();

                //Geodaten holen.
                //Entweder wurde lat und lng geliefert, oder wir müssen über den benutzer und den app-mode entscheiden
                var (country, state) = await GetGeoDataAsync(model);

                var queryResult = await _advertisementService.GetByCategoryForAppAsync(model.CategoryId, country, state, model.Location.Lat.Value, model.Location.Lng.Value, model.Language, LocalizationOptions.Value.DefaultCulture, model.Skip, model.Take);

                response.Total = queryResult.total;

                var dtoList = Mapper.Map<List<AdvertisementDto>>(queryResult.list);
                var baseAddress = GetBaseAddress();
                foreach (var dtoItem in dtoList)
                {
                    if (!string.IsNullOrWhiteSpace(dtoItem.Image))
                        dtoItem.Image = $"{baseAddress}/file/documents/thumbnails/{400}/{dtoItem.Image}";
                    if (!string.IsNullOrWhiteSpace(dtoItem.Image2))
                        dtoItem.Image2 = $"{baseAddress}/file/documents/thumbnails/{400}/{dtoItem.Image2}";
                    if (!string.IsNullOrWhiteSpace(dtoItem.ImageLanguage))
                        dtoItem.ImageLanguage = $"{baseAddress}/file/documents/thumbnails/{400}/{dtoItem.ImageLanguage}";
                    if (!string.IsNullOrWhiteSpace(dtoItem.Image2Language))
                        dtoItem.Image2Language = $"{baseAddress}/file/documents/thumbnails/{400}/{dtoItem.Image2Language}";
                }

                response.List = dtoList;
                response.Take = model.Take;
                response.Skip = model.Skip;

                return Ok(response);

            }
            return NotFound(CommunicationErrors.Common_NotFound);
        }
    }
}