using System;
using AutoMapper;
using gehGassi.Core.Interfaces;
using gehGassi.Core.Services;
using gehGassi.Permissions;
using gehGassi.Web.Auth.Attributes;
using gehGassi.Web.Auth;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Localization;
using gehGassi.Common.Data;
using gehGassi.Domain.Common;
using System.Collections.Generic;
using System.Linq;
using gehGassi.Web.Helper;
using gehGassi.Web.Models;
using System.IO;
using System.Threading.Tasks;
using System.Security.Cryptography;
using NetTopologySuite.Algorithm;
using gehGassi.External.Services;
using NetTopologySuite.Geometries;
using NetTopologySuite;
using CsvHelper.Configuration;
using System.Globalization;
using CsvHelper;
using System.Net;
using System.Text;

namespace gehGassi.Web.Controllers
{
    /// <summary>
    /// Controller für die Verwaltung von Gutscheinen
    /// </summary>
    [Authorize]
    public class VoucherController : BaseController
    {
        private readonly IMapper _mapper;
        private readonly IStringLocalizer<VoucherController> _localizer;
        private readonly ILanguageService _languageService;
        private readonly IVoucherCampaignService _voucherCampaignService;
        private readonly ICountryService _countryService;
        private readonly ICustomerService _customerService;
        private readonly IMangoPayService _mangoPayService;
        private readonly IFileService _fileService;

        /// <summary>
        /// Erstellt eine Instanz
        /// </summary>
        /// <param name="mapper">Instanz eines IMapper</param>
        /// <param name="localizer">Instanz eines IStringLocalizer</param>
        /// <param name="languageService">Instanz eines ILanguageService</param>
        /// <param name="voucherCampaignService">Instanz eines IBannerService</param>
        /// <param name="countryService">Instanz eines ICountryService</param>
        /// <param name="customerService">Instanz eines ICustomerService</param>
        /// <param name="mangoPayService">Instanz eines IMangoPayService</param>
        /// <param name="fileService">Instanz eines IFileShareService</param>
        public VoucherController(IMapper mapper, IStringLocalizer<VoucherController> localizer, ILanguageService languageService, IVoucherCampaignService voucherCampaignService, ICountryService countryService, 
            ICustomerService customerService, IMangoPayService mangoPayService, IFileService fileService)
        {
            _mapper = mapper;
            _localizer = localizer;
            _languageService = languageService;
            _voucherCampaignService = voucherCampaignService;
            _countryService = countryService;
            _customerService = customerService;
            _mangoPayService = mangoPayService;
            _fileService = fileService;
        }

        #region Admin PowerUser - Kampagnen

        /// <summary>
        /// Gibt einen View für die Verwaltung von Gutscheinen zurück
        /// </summary>
        /// <returns>View</returns>
        [Authorize(Policy = Policies.PowerUserOnly)]
        [HasPermission(Permission.VouchersManage, Permission.VouchersRead)]
        public IActionResult IndexCampaigns()
        {
            return View();
        }

        /// <summary>
        /// Gibt eine Liste von Entitäten basierend auf Abfragekriterien zurück
        /// </summary>
        /// <param name="dm">Abfragekriterien</param>
        /// <returns>Liste von gefundenen Entitäten</returns>
        [Authorize(Policy = Policies.PowerUserOnly)]
        [HasPermission(Permission.VouchersManage, Permission.VouchersRead)]
        [HttpPost]
        [ResponseCache(Duration = 0, Location = ResponseCacheLocation.None, NoStore = true)]
        public IActionResult GetCampaigns([FromBody] DataManager dm)
        {
            if (dm != null)
            {
                var propList = new List<ComplexProperty>();
                dm.SetComplexProperties(propList);

                if (dm.Where != null)
                {
                    foreach (var whereFilter in dm.Where)
                    {
                        if (whereFilter.predicates == null)
                            continue;
                        foreach (var whereFilterPredicate in whereFilter.predicates)
                        {
                            if (whereFilterPredicate.Field == "campaignType")
                                whereFilterPredicate.value = (VoucherCampaignType)((int)((long)whereFilterPredicate.value));
                            if (whereFilterPredicate.Field == "status")
                                whereFilterPredicate.value = (VoucherCampaignStatus)((int)((long)whereFilterPredicate.value));
                            if (whereFilterPredicate.Field == "paymentType")
                                whereFilterPredicate.value = (PaymentType)((int)((long)whereFilterPredicate.value));
                            if (whereFilterPredicate.Field == "paymentStatus")
                                whereFilterPredicate.value = (PaymentStatus)((int)((long)whereFilterPredicate.value));
                            if (whereFilterPredicate.Field == "geoMode")
                                whereFilterPredicate.value = (GeoMode)((int)((long)whereFilterPredicate.value));
                        }
                    }
                }
            }

            var resultList = _voucherCampaignService.FilterWithNames(dm?.SearchValue ?? "", SelectedLanguage, FallbackLanguage, includeDeleted: false, excludeDraft: true);

            //Sortierung
            resultList = dm.ApplySorting(resultList);
            //Filter
            resultList = dm.ApplyFiltering(resultList, out var countFiltered);
            //Paging
            resultList = dm.ApplyPaging(resultList);

            var resultListVm = resultList.ToList().Select(item => _mapper.Map<VoucherCampaignListVm>(item)).ToList();

            foreach (var itemVm in resultListVm)
            {
                itemVm.CampaignTypeText = itemVm.CampaignType.GetDisplayName(AnnotationsLocalizer);
                itemVm.StatusText = itemVm.Status.GetDisplayName(AnnotationsLocalizer);
                itemVm.PaymentTypeText = itemVm.PaymentType.GetDisplayName(AnnotationsLocalizer);
                itemVm.PaymentStatusText = itemVm.PaymentStatus.GetDisplayName(AnnotationsLocalizer);
                itemVm.GeoModeText = itemVm.GeoMode.GetDisplayName(AnnotationsLocalizer);
            }

            //FilterPreview?
            if (!dm.RequiresCounts)
                return Json(resultListVm);

            return Json(new { result = resultListVm, count = countFiltered });
        }

        /// <summary>
        /// Anlegen einer Gutschein-Kampagne
        /// </summary>
        /// <returns>PartialView</returns>
        [Authorize(Policy = Policies.PowerUserOnly)]
        [HasPermission(Permission.VouchersManage, Permission.VouchersCreate)]
        [ResponseCache(Duration = 0, Location = ResponseCacheLocation.None, NoStore = true)]
        public IActionResult CreateCampaign()
        {
	        var model = new VoucherCampaignCrudVm()
	        {
		        Id = Guid.NewGuid().ToString("N"),
		        TextVms = new List<VoucherCampaignTextVm>(),
		        CustomerName = _localizer["Common_None"],
                CampaignType = VoucherCampaignTypeVm.SingleVoucher,
		        Status = VoucherCampaignStatusVm.Draft,
		        PaymentType = PaymentTypeVm.None,
		        PaymentStatus = PaymentStatusVm.None,
		        GeoMode = GeoModeVm.None,
		        NumberOfVouchers = 1,
		        VouchersUsed = 0,
		        Budget = 0,
		        BudgetUsed = 0,
		        MaxUsagePerUser = 1,
		        VoucherAmmount = 0
	        };

	        foreach (var language in _languageService.GetAllIso2())
	        {
		        model.TextVms.Add(new VoucherCampaignTextVm() { Id = model.Id, Language = language, Name = string.Empty, ImageLanguage = string.Empty });
	        }

	        return PartialView("_CreateCampaign", model);
        }

		/// <summary>
		/// Anlegen einer Gutschein-Kampagne
		/// </summary>
		/// <param name="model">Model</param>
		/// <returns>Json</returns>
		[Authorize(Policy = Policies.PowerUserOnly)]
		[HasPermission(Permission.VouchersManage, Permission.VouchersCreate)]
		[ValidateAntiForgeryToken]
		[HttpPost]
		public async Task<IActionResult> CreateCampaign(VoucherCampaignCrudVm model)
		{
			var result = new ResponseVm { Success = false };

			if (ModelState.IsValid)
			{
				var item = _voucherCampaignService.Create();
				_mapper.Map(model, item);
				item.Created = DateTimeOffset.UtcNow;
				item.UpdatedAt = DateTimeOffset.UtcNow;

				// Texte setzen
				foreach (var textVm in model.TextVms)
				{
					item.Set("Name", textVm.Language, textVm.Name);
					item.Set("ImageLanguage", textVm.Language, textVm.ImageLanguage);
					item.Set("UrlLanguage", textVm.Language, textVm.UrlLanguage);

					if (!string.IsNullOrWhiteSpace(textVm.ImageLanguage))
					{
						//Neue Bilddaten verwenden....
						var extension = Path.GetExtension(textVm.ImageLanguage);
						var fileName = Path.GetFileName(textVm.ImageLanguage);
						var filenameToUse = FileServiceHelper.GetVoucherCampaignPath(item.Id) + $"vc_{textVm.Language}-{Guid.NewGuid():N}{extension}";
						item.Set("ImageLanguage", textVm.Language, filenameToUse);

						//Kopieren
						var tempFile = await FileService.GetAsync(FileServiceHelper.TempContainer, textVm.ImageLanguage);
						await FileService.StoreAsync(FileServiceHelper.DocumentContainer, filenameToUse, tempFile);

						//Thumbnails
						//Thumbnails
						await GenerateThumbnailByWidth(FileServiceHelper.DocumentContainer, filenameToUse, 400);
						await GenerateThumbnailByWidth(FileServiceHelper.DocumentContainer, filenameToUse, 200);
						await GenerateThumbnailByWidth(FileServiceHelper.DocumentContainer, filenameToUse, 100);
					}
				}

                //Wallets erstellen
                var customerItem = await _customerService.GetAsync(model.CustomerId);
                if (customerItem != null)
                {
                    var creditsResult = await _mangoPayService.CreateWalletForCustomerAsync(customerItem.UniqueId.Value.ToString(), WalletType.CustomerCreditsVoucherCampaign, $"VoucherCampaign_{item.Prefix}_Credit");
                    var feesResult = await _mangoPayService.CreateWalletForCustomerAsync(customerItem.UniqueId.Value.ToString(), WalletType.CustomerTransactionVoucherCampaign, $"VoucherCampaign_{item.Prefix}_Transaction");

                    if (creditsResult.Success && feesResult.Success)
                    {
                        item.WalletCreditId = creditsResult.Value.Id;
                        item.WalletFeeId = feesResult.Value.Id;

                        _voucherCampaignService.Add(item);
                        await _voucherCampaignService.CommitAsync(User.Identity.Name);

                        if (!string.IsNullOrWhiteSpace(model.Image))
                        {
                            //Nun das Bild umbenennen und dann kopieren. Ebenso Thumbnails erstellen
                            var extension = Path.GetExtension(model.Image);
                            var fileName = Path.GetFileName(model.Image);

                            var filenameToUse = FileServiceHelper.GetVoucherCampaignPath(item.Id) + $"vc_{Guid.NewGuid():N}{extension}";
                            item.Image = filenameToUse;
                            await _voucherCampaignService.CommitAsync(User.Identity.Name);

                            //Kopieren
                            var tempFile = await FileService.GetAsync(FileServiceHelper.TempContainer, model.Image);
                            await FileService.StoreAsync(FileServiceHelper.DocumentContainer, filenameToUse, tempFile);

                            await GenerateThumbnailByWidth(FileServiceHelper.DocumentContainer, filenameToUse, 400);
                            await GenerateThumbnailByWidth(FileServiceHelper.DocumentContainer, filenameToUse, 200);
                            await GenerateThumbnailByWidth(FileServiceHelper.DocumentContainer, filenameToUse, 100);

                            //Altes Löschen
                            await FileService.DeleteAsync(FileServiceHelper.TempContainer, model.Image);
                        }

                        //Gutscheine für die Kampagne anlegen
                        await _voucherCampaignService.CreateVouchersForCampaign(item.Id, User.Identity.Name);

                        result.Data = item.ToCamelCaseJson();
                        result.Success = true;
                        result.Html = string.Empty;
                        return Json(result);
                    }
                    else
                    {
                        ModelState.AddModelError("CustomerId", _localizer["VoucherCampaign_CustomerId_MangopayError"]);
                    }
                }
                else
                {
                    ModelState.AddModelError("CustomerId", _localizer["VoucherCampaign_CustomerId_NotFound"]);
                }
			}

			ModelState.Remove("CountryName");
			var country = _countryService.GetCountry(model.Address.CountryCode);
			model.CountryName = country != null ? country.Name : "";

			ModelState.Remove("StateName");
			var state = _countryService.GetState(model.Address.CountryCode, model.Address.State);
			model.StateName = state != null ? state.Name : "";

			ModelState.Remove("CustomerName");
			var customer = await _customerService.GetAsync(model.CustomerId);
			model.CustomerName = customer != null ? customer.Name : "";

			result.Html = await PartialView("_CreateCampaign", model).ToStringAsync(ControllerContext);
			return Json(result);
		}

        /// <summary>
        /// Bearbeiten einer Gutschein-Kampagne
        /// </summary>
        /// <param name="id">Id des Kampagne</param>
        /// <returns>PartialView</returns>
        [Authorize(Policy = Policies.PowerUserOnly)]
        [HasPermission(Permission.VouchersManage, Permission.VouchersEdit)]
        [ResponseCache(Duration = 0, Location = ResponseCacheLocation.None, NoStore = true)]
        public async Task<IActionResult> EditCampaign(string id)
        {
            var item = await _voucherCampaignService.GetAsync(id);
            if (item != null)
            {
                var model = _mapper.Map<VoucherCampaignCrudVm>(item);

                model.TextVms = new List<VoucherCampaignTextVm>();
                foreach (var language in _languageService.GetAllIso2())
                {
                    model.TextVms.Add(new VoucherCampaignTextVm()
                    {
                        Id = item.Id,
                        Language = language,
                        Name = item.Get("Name", language, true),
                        ImageLanguage = item.Get("ImageLanguage", language, true),
                        UrlLanguage = item.Get("UrlLanguage", language, true)
                    });
                }

                var country = _countryService.GetCountry(model.Address.CountryCode);
                model.CountryName = country != null ? country.Name : "";

                var state = _countryService.GetState(model.Address.CountryCode, model.Address.State);
                model.StateName = state != null ? state.Name : "";

                var customer = await _customerService.GetAsync(model.CustomerId);
                model.CustomerName = customer != null ? customer.Name : "";

                return PartialView("_EditCampaign", model);
            }
            return PartialView("_Error");
        }

        /// <summary>
        /// Bearbeiten einer Gutschein-Kampagne
        /// </summary>
        /// <param name="model">Model</param>
        /// <returns>Json</returns>
        [Authorize(Policy = Policies.PowerUserOnly)]
        [HasPermission(Permission.VouchersManage, Permission.VouchersEdit)]
        [ValidateAntiForgeryToken]
        [HttpPost]
        public async Task<IActionResult> EditCampaign(VoucherCampaignCrudVm model)
        {
            var result = new ResponseVm { Success = false };

            if (ModelState.IsValid)
            {
                var item = await _voucherCampaignService.GetAsync(model.Id);
                if (item is { Deleted: false })
                {
                    if (item.Version.SequenceEqual(model.Version))
                    {
                        var oldImage = item.Image;
                        var oldVoucherAmmount = item.VoucherAmmount;

                        _mapper.Map(model, item);

                        //Texte setzen
                        foreach (var textVm in model.TextVms)
                        {
                            item.Set("Name", textVm.Language, textVm.Name);
                            var oldLangImage = item.Get("ImageLanguage", textVm.Language, true);
                            item.Set("ImageLanguage", textVm.Language, textVm.ImageLanguage);
                            item.Set("UrlLanguage", textVm.Language, textVm.UrlLanguage);

                            if (oldLangImage != textVm.ImageLanguage)
                            {
                                //Alte Daten löschen, neue Daten anlegen
                                if (!string.IsNullOrWhiteSpace(oldLangImage))
                                {
                                    await FileService.DeleteAsync(FileServiceHelper.DocumentContainer, oldLangImage);
                                    await RemoveThumbnail(FileServiceHelper.DocumentContainer, oldLangImage, 400);
                                    await RemoveThumbnail(FileServiceHelper.DocumentContainer, oldLangImage, 200);
                                    await RemoveThumbnail(FileServiceHelper.DocumentContainer, oldLangImage, 100);
                                }

                                if (!string.IsNullOrWhiteSpace(textVm.ImageLanguage))
                                {
                                    //Neue Bilddaten verwenden....
                                    var extension = Path.GetExtension(textVm.ImageLanguage);
                                    var fileName = Path.GetFileName(textVm.ImageLanguage);
                                    var filenameToUse = FileServiceHelper.GetVoucherCampaignPath(item.Id) + $"bn_{textVm.Language}-{Guid.NewGuid():N}{extension}";
                                    item.Set("ImageLanguage", textVm.Language, filenameToUse);


                                    //Kopieren
                                    var tempFile = await FileService.GetAsync(FileServiceHelper.TempContainer, textVm.ImageLanguage);
                                    await FileService.StoreAsync(FileServiceHelper.DocumentContainer, filenameToUse, tempFile);

                                    //Thumbnails
                                    await GenerateThumbnailByWidth(FileServiceHelper.DocumentContainer, filenameToUse, 400);
                                    await GenerateThumbnailByWidth(FileServiceHelper.DocumentContainer, filenameToUse, 200);
                                    await GenerateThumbnailByWidth(FileServiceHelper.DocumentContainer, filenameToUse, 100);
                                }
                            }
                        }

                        item.UpdatedAt = DateTimeOffset.UtcNow;

                        if (oldImage != item.Image)
                        {
                            //Alte Daten löschen, neue Daten anlegen
                            if (!string.IsNullOrWhiteSpace(oldImage))
                            {
                                //Alte Daten löschen, neue Daten anlegen
                                if (!string.IsNullOrWhiteSpace(oldImage))
                                {
                                    await FileService.DeleteAsync(FileServiceHelper.DocumentContainer, oldImage);
                                    await RemoveThumbnail(FileServiceHelper.DocumentContainer, oldImage, 400);
                                    await RemoveThumbnail(FileServiceHelper.DocumentContainer, oldImage, 200);
                                    await RemoveThumbnail(FileServiceHelper.DocumentContainer, oldImage, 100);
                                }
                            }

                            if (!string.IsNullOrWhiteSpace(item.Image))
                            {
                                //Neue Bilddaten verwenden....
                                var extension = Path.GetExtension(item.Image);
                                var fileName = Path.GetFileName(item.Image);
                                var filenameToUse = FileServiceHelper.GetVoucherCampaignPath(item.Id) + $"ls_{Guid.NewGuid():N}{extension}";
                                item.Image = filenameToUse;

                                //Kopieren
                                var tempFile = await FileService.GetAsync(FileServiceHelper.TempContainer, model.Image);
                                await FileService.StoreAsync(FileServiceHelper.DocumentContainer, filenameToUse, tempFile);

                                //Thumbnails
                                await GenerateThumbnailByWidth(FileServiceHelper.DocumentContainer, filenameToUse, 400);
                                await GenerateThumbnailByWidth(FileServiceHelper.DocumentContainer, filenameToUse, 200);
                                await GenerateThumbnailByWidth(FileServiceHelper.DocumentContainer, filenameToUse, 100);
                            }
                        }

                        await _voucherCampaignService.CommitAsync(User.Identity.Name);

                        if (oldVoucherAmmount != item.VoucherAmmount)
                        {
                            //Gutscheine die noch nicht verwendet wurden, aktualisieren
                            await _voucherCampaignService.UpdateVoucherAmmountAsync(item.Id, item.VoucherAmmount);
                            await _voucherCampaignService.CommitAsync(User.Identity.Name, noAudit: true);
                        }

                        result.Data = item.ToCamelCaseJson();
                        result.Success = true;
                        result.Html = string.Empty;
                        return Json(new { result.Success, result.Html, result.Data });
                    }
                    else
                    {
                        ModelState.AddModelError("", _localizer["Err_Entity_Changed"].Value);
                    }
                }
                else
                {
                    ModelState.AddModelError("", _localizer["Err_Entity_Deleted"].Value);
                }
            }

            ModelState.Remove("CountryName");
            var country = _countryService.GetCountry(model.Address.CountryCode);
            model.CountryName = country != null ? country.Name : "";

            ModelState.Remove("StateName");
            var state = _countryService.GetState(model.Address.CountryCode, model.Address.State);
            model.StateName = state != null ? state.Name : "";

            ModelState.Remove("CustomerName");
            var customer = await _customerService.GetAsync(model.CustomerId);
            model.CustomerName = customer != null ? customer.Name : "";

            result.Html = await PartialView("_EditCampaign", model).ToStringAsync(ControllerContext);
            return Json(result);
        }

        /// <summary>
        /// Löschen einer Gutschein-Kampagne
        /// </summary>
        /// <param name="ids">Liste Id der Entität</param>
        /// <param name="forceDelete">Sollen die Daten physisch gelöscht werden?</param>
        /// <returns>Json</returns>
        [Authorize(Policy = Policies.PowerUserOnly)]
        [HasPermission(Permission.VouchersManage, Permission.VouchersDelete)]
        [HttpPost]
        public async Task<IActionResult> DeleteCampaign(List<string> ids, bool forceDelete = false)
        {
            var batchErrorHeader = $"<p><strong>{_localizer["Common_BatchDelete_Failed"].Value}</strong></p>";
            var batchResult = new BatchResponseVm(batchErrorHeader) { Success = true };

            foreach (var id in ids)
            {
                var item = await _voucherCampaignService.GetAsync(id);
                if (item != null)
                {
                    //await _customerService.ResetTypeAsync(item.Id); //Spezial zurücksetzen wenn nötig
                    var usedCount = 0;

                    //var productsCount = await _productService.CountByAdvertisementCategoryAsync(item.Id);
                    //usedCount += productsCount;

                    if (usedCount == 0)
                    {
                        //TODO: Gibt es Resets die notwendig sind?
                        //await _productService.ResetAdvertisementCategoryAsync(item.Id, true);

                        batchResult.BatchResponseList.Add(new BatchResponseItemVm() { Id = item.Id.ToString(), Name = item.Name, Success = true, NotFound = false, ErrorMessage = "" });

                        if (forceDelete)
                        {
                            var postingPath = FileServiceHelper.GetVoucherCampaignPath(item.Id);
                            await FileService.ClearDirectoryAsync(FileServiceHelper.DocumentContainer, postingPath);
                            await RemoveThumbnail(FileServiceHelper.DocumentContainer, item.Image, 400);
                            await RemoveThumbnail(FileServiceHelper.DocumentContainer, item.Image, 200);
                            await RemoveThumbnail(FileServiceHelper.DocumentContainer, item.Image, 100);

                            var languages = item.GetLanguages("ImageLanguage");
                            foreach (var language in languages)
                            {
                                item.SetLanguage(language);
                                var imageLocalized = item.ImageLanguage;
                                if (!string.IsNullOrWhiteSpace(imageLocalized))
                                {
                                    await RemoveThumbnail(FileServiceHelper.DocumentContainer, imageLocalized, 400);
                                    await RemoveThumbnail(FileServiceHelper.DocumentContainer, imageLocalized, 200);
                                    await RemoveThumbnail(FileServiceHelper.DocumentContainer, imageLocalized, 100);
                                }
                            }

                            await _voucherCampaignService.RemoveVouchersAsync(item.Id);

                            _voucherCampaignService.Remove(item);
                        }
                        else
                        {
                            item.Deleted = true;
                            item.UpdatedAt = DateTimeOffset.UtcNow;

                            await _voucherCampaignService.RemoveVouchersAsync(item.Id);
                        }
                    }
                    else
                    {
                        if (usedCount != 0)
                        {
                            batchResult.Success = false;
                            batchResult.BatchResponseList.Add(new BatchResponseItemVm() { Id = id.ToString(), Name = item.Name, Success = false, NotFound = false, ErrorMessage = string.Format(_localizer["Common_BatchDelete_InUse"], $"<strong>{item.Name}</strong>", $"<strong>{usedCount}</strong>") + "<br/>" });
                        }
                    }
                }
                else
                {
                    batchResult.Success = false;
                    batchResult.BatchResponseList.Add(new BatchResponseItemVm() { Id = id.ToString(), Name = "", Success = false, NotFound = true, ErrorMessage = string.Format(_localizer["Common_BatchDelete_NotFound"], $"<strong>{id}</strong>") + "<br/>" });
                }
            }
            if (batchResult.BatchResponseList.Any(c => c.Success))
                await _voucherCampaignService.CommitAsync(User.Identity.Name);
            return Json(batchResult);
        }

        /// <summary>
        /// Exportiert die Gutscheine einer Kampagne
        /// </summary>
        /// <param name="voucherCampaignId">Id der Kampagne</param>
        /// <returns>Task</returns>
        [Authorize(Policy = Policies.PowerUserOnly)]
        [HasPermission(Permission.VouchersManage, Permission.VouchersEdit)]
        [HttpPost]
        public async Task<IActionResult> Export(string voucherCampaignId)
        {
            var result = new ResponseVm { Success = false };
            var exportItems = new List<VoucherExportDto>();

            var item = await _voucherCampaignService.GetAsync(voucherCampaignId);
            if (item is { Deleted: false })
            {
                var vouchers = await _voucherCampaignService.GetVouchersForCampaignAsync(voucherCampaignId);
                foreach (var voucher in vouchers)
                {
                    exportItems.Add(new VoucherExportDto()
                    {
                        Code = voucher.Code,
                        QrCode = voucher.QrCode,
                        VoucherAmmount = voucher.VoucherAmmount
                    });
                }

                if (exportItems.Count > 0)
                {
                    await using var writer = new StringWriter();
                    await using (var csv = new CsvWriter(writer, new CsvConfiguration(CultureInfo.InvariantCulture) { Delimiter = ";" }))
                    {
                        await csv.WriteRecordsAsync(exportItems);
                    }

                    var csvContent = writer.ToString();

                    var fileName = $"Vouchers_{DateTime.Now.Year}-{DateTime.Now.Month}-{DateTime.Now.Day}-{DateTime.Now.Hour}-{DateTime.Now.Minute}-{DateTime.Now.Second}.csv";
                    var filenameToUse = FileServiceHelper.GetCustomerPath(item.CustomerId) + fileName;
                    var file = Encoding.UTF8.GetBytes(csvContent);
                    await _fileService.StoreAsync(FileServiceHelper.TempContainer, filenameToUse, file, true);

                    var targetFile = $"{HttpContext.Request.Scheme}://{HttpContext.Request.Host}/File/{FileServiceHelper.TempContainer}/{FileServiceHelper.GetCustomerPath(item.CustomerId)}{fileName}";

                    result.Data = targetFile;
                    result.Success = true;
                    result.Html = string.Empty;
                    return Json(result);
                }
            }
            else
            {
                ModelState.AddModelError("", _localizer["Err_Entity_Deleted"].Value);
            }

            return Json(result);
        }

        #endregion

        #region Helper

        /// <summary>
        /// Überprüft ob ein Präfix für eine Kampagne verfügbar ist
        /// </summary>
        /// <returns>true wenn möglich, false sonst</returns>
        [HttpPost]
        public async Task<IActionResult> IsPrefixAvailable(string prefix, string id)
        {
            return Json(await _voucherCampaignService.IsPrefixAvailableAsync(prefix, id));
        }

        #endregion
    }
}