@using System
@using System.Globalization
@using System.Linq
@using Resto.Front.PrintTemplates.Cheques.Razor
@using Resto.Front.PrintTemplates.Cheques.Razor.TemplateModels
@using Newtonsoft.Json
@using System.IO

@inherits TemplateBase<IReceiptCheque>
@{
    var chequeTask = Model.ChequeTask;
    var order = Model.Order;
    var sum = chequeTask.Sales.Sum(sale => sale.GetCost() - sale.DiscountSum + sale.IncreaseSum).RoundMoney();
    var countCheck = 1;
    paymentsTypesName = new List<string>();

if (order.Delivery != null)
    {
        if(!order.Delivery.IsSelfService)
        {
            throw new OperationCanceledException("Stop printing - delivery order no."+@order.Number);
        }
    }
/*
     try
        {
            string path = string.Format("{0}\\iiko\\CashServer\\Jsons\\",Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData));
            var chequeName = "order_"+order.Number;
            var jsonModel = JsonConvert.SerializeObject(Model.CommonInfo);
            string fullFileName = path + chequeName +"_"+DateTime.Now.ToString("dd-MM-yyyy_HH-mm-ss")+".json";
            if (!System.IO.Directory.Exists(path))
            {
            System.IO.Directory.CreateDirectory(path);
            }
             File.WriteAllText(fullFileName , jsonModel);
           
        }
        catch (Exception)
        {

        }*/

try
{
    if(Model.Extensions.BeforeCheque != null && Model.Extensions.BeforeCheque.Count() > 0)
    {
        var i = 0;
     foreach (var item in Model.Extensions.BeforeCheque)
     {
        if(item != null)
        {
        i++;
       }
     }
    }
}
catch (Exception)
{

}

}


   

             
<doc>
@for (int i = 0; i < countCheck; i++)
            {

if(i>0)
{

<pagecut />
}
    if (!Model.ChequeInfo.IsForReport)
    {
<line symbols="*" />
 <center><f2>Eleni's Pizza Works</f2></center>
    <center>6711 15th St E,  Sarasota, FL 34243</center>

<line symbols="*" />

    }
    <pair left="Current terminal: @Model.CommonInfo.CurrentTerminal" right="" />
   
    if (!Model.ChequeInfo.IsForReport)
    {
        <pair left="@string.Format(Resources.CashRegisterFormat, Model.ChequeInfo.Session.CashRegisterNumber)" right="@string.Format("{0}{1}", Resources.HeadCashRegisterShift,  Model.ChequeInfo.Session.Number)" />
    }
    if(chequeTask.IsStorno)
    { 
        <center>@(chequeTask.IsStorno ? Resources.StornoCheque : chequeTask.IsBuy ? Resources.OrderBuyReceipt : Resources.OrderPaymentReceipt)</center>
    }
   <pair left="@Resources.CurrentDate" right="@FormatDateTimeCustom(Model.CommonInfo.CurrentTime, "MM/dd/yyyy hh:mm tt")" />
    <pair left="@string.Format(Resources.BillHeaderCashierPattern, chequeTask.CashierName)" right="@string.Format(Resources.BillHeaderWaiterPattern, order.Waiter.GetNameOrEmpty())" />
    <center><f2>Check #@order.Number</f2></center>

    @Items(order)
    
   foreach (var discountItem in Model.Order.DiscountItems)
    {
         <table>
        <columns>
            <column formatter="split" />
            <column />
            <column align="right" autowidth="" />
        </columns>
        <cells>
            <c colspan="2">@discountItem.Type.Name</c>
            <ct>$@FormatMoney(discountItem.DiscountSums.Sum(x => x.Value)*-1)</ct>
        </cells>
    </table>
    }

  var taxSum = 0m;
   foreach (var guest in Model.Order.Guests)
   {
      taxSum += guest.Items.Sum(item => item.IncludedVat);
      taxSum += guest.Items.Sum(item => item.ExcludedVat);
   }
   
    <pair left="Sales tax:" right="$@FormatMoneyFractional(taxSum)" />

  

    <pair left="@Resources.BillFooterTotal" right="$@FormatMoney(chequeTask.ResultSum)" />
    
    @Payments(chequeTask, order)
    
    

    if(paymentsTypesName.Count > 0)
    {
 <whitespace-preserve>@Raw(string.Join(Environment.NewLine, Model.Extensions.BeforeCheque))</whitespace-preserve>
 
    }
    else
    {
if (!Model.ChequeInfo.IsForReport)
    {
        <np />
        <np />
    <center>Order online  www.elenispizzaworks.com</center>
         <np />

if(false)
{
<center>Scan QR with your</center>
<center>Mobile Phone</center>
    <qrcode size="normal" correction="low">https://bit.ly/3Dhq2Wq</qrcode>
<center>Review Us on Google!</center>
    <np />
}
    }
    <whitespace-preserve>@Raw(string.Join(Environment.NewLine, Model.Extensions.AfterCheque))</whitespace-preserve>
    if (!chequeTask.IsStorno)
    {
        <np />
        <line />
        <center>@Resources.Signature</center>
    }
}
}
</doc>


@helper Items(IOrder order)
{
    <line />
    if (order == null || order.Guests == null || order.Guests.Count() == 0 )
    {
        @Resources.ZeroChequeBody
        <line />
    }
    var guestsItems = order.Guests.Where(x => x.Items != null && x.Items.Count() > 0);
    if (guestsItems == null || guestsItems.Count() == 0 )
    {
        @Resources.ZeroChequeBody
        <line />
    }
    var orderItems = guestsItems.SelectMany(x => x.Items).Where( x => x.DeletionInfo == null).ToList();

    if (orderItems == null || orderItems.Count() == 0)
    {
        @Resources.ZeroChequeBody
        <line />
    }
    else if (Model.IsFullCheque)
    {
        <table>
            <columns>
                <column formatter="split" />
                <column align="right" autowidth="" />
                <column align="right" autowidth="" />
          </columns>
            <cells>
                @if (!Model.ChequeInfo.IsForReport)
                {
                  <ct>Item</ct>
                  <ct>@Resources.AmountShort</ct>
                  <ct>@Resources.ProductSum</ct>
                  <linecell />
                }
                @GuestsItems(orderItems)
          </cells>
        </table>
        <line />
    }
}

@helper GuestsItems(ICollection<IOrderItem> items)
{
    foreach (var comboGroup in items.Where(item => item.DeletionInfo == null).GroupBy(i => i.Combo))
    {
        var combo = comboGroup.Key;
        if (combo != null)
        {
            <c><f0>@combo.Name</f0></c>
            <c><right>@(string.Format("{0} x", FormatAmount(combo.Amount)))</right></c>
            <ct>$@FormatMoney(combo.Price * combo.Amount)</ct>
        }
        foreach (var orderItem in comboGroup.OrderBy(i => i.OrderRank))
        {
            @OrderItem(orderItem, combo != null)
        }
    }
}

@helper OrderItem(IOrderItem item, bool isPartOfCombo)
{
    var productItem = item as IProductItem;
    var additionalSpace = isPartOfCombo ? " " : string.Empty;
    if (productItem != null && productItem.CompoundsInfo != null && productItem.CompoundsInfo.IsPrimaryComponent)
    {
        <c colspan="3"><whitespace-preserve><f0>@(additionalSpace + string.Format("{0} {1}", productItem.CompoundsInfo.ModifierSchemaName, productItem.ProductSize == null ? string.Empty : productItem.ProductSize.Name))</f0></whitespace-preserve></c>
        // у пиццы не может быть удаленных модификаторов, поэтому берем весь список
        foreach (var orderEntry in productItem.ModifierEntries.Where(orderEntry => ModifiersFilter(orderEntry, productItem, true)))
        {
            <c><whitespace-preserve>@(string.Format("  {0}",orderEntry.Product.Name))</whitespace-preserve></c>
                    if (orderEntry.Amount != 1m)
                    {
                        <ct>@FormatAmount(orderEntry.Amount)</ct>
                    }
                    else
                    {
                        <ct/>
                    }
            if (orderEntry.Cost != 0m)
            {
                <ct>$@FormatMoney(orderEntry.Cost)</ct>
            }
            else
            {
                <c/>
            }
        }
    }

    if (productItem != null && productItem.CompoundsInfo != null)
    {
        <c><whitespace-preserve>@("1/2 " + GetOrderEntryNameWithProductSize(productItem))</whitespace-preserve></c>
    }
    else
    {
        <c><whitespace-preserve><f0>@GetOrderEntryNameWithProductSize(item)</f0></whitespace-preserve></c>
    }

    if (!isPartOfCombo)
    {
       if (productItem.Amount != 1m)
                    {
                        <ct>@FormatAmount(productItem.Amount)</ct>
                    }
                    else
                    {
                        <ct/>
                    }
   <ct>$@FormatMoney(productItem.Cost)</ct>
    }
    else
    {
         if (productItem.Amount != 1m)
                    {
                        <ct>@FormatAmount(productItem.Amount)</ct>
                    }
                    else
                    {
                        <ct/>
                    }
                    <c/>
    }


    foreach (var orderEntry in item.GetNotDeletedChildren().Where(orderEntry => ModifiersFilter(orderEntry, item))
        .Where(orderEntry => orderEntry.Cost > 0 || orderEntry.Product.PrechequePrintable).ToList())
    {
        <c><whitespace-preserve>@(string.Format("  {0}",orderEntry.Product.Name))</whitespace-preserve></c>
 if (orderEntry.Amount != 1m)
                    {
                        <ct>@FormatAmount(orderEntry.Amount)</ct>
                    }
                    else
                    {
                        <ct />
                    }
        if (orderEntry.Cost != 0m)
        {
            <ct>$@FormatMoney(orderEntry.Cost)</ct>
        }
        else
        {
            <c/>
        }
    }
}



@helper DiscountIncrease(IChequeTaskDiscountItem discountItem)
{
    <table>
        <columns>
            <column formatter="split" />
            <column />
            <column align="right" autowidth="" />
        </columns>
        <cells>
            <c>@discountItem.Name</c>
            <c>@FormatPercent(discountItem.Percent)</c>
            <ct>$@FormatMoney(discountItem.Sum)</ct>
        </cells>
    </table>
}

@helper VatsOld(IChequeTask chequeTask)
{


    var vats = chequeTask.Sales
        .GroupBy(sale => sale.NdsPercent)
        .Where(group => group.Key > 0m)
        .Select(group => Tuple.Create(group.Key, group.Sum(sale => (sale.ResultSum - sale.ResultSum / (1m + @group.Key / 100m)).RoundMoneyFractional())))
        .ToList();

    var vatSum = vats.Sum(tuple => tuple.Item2);

    if (vatSum != 0)
    {
        <pair left="@Resources.ResultSumWithoutNds" right="$@FormatMoneyFractional(chequeTask.ResultSum - vatSum)" />
        foreach (var percentAndSum in vats)
        {
            <pair left="Sales tax" right="$@FormatMoneyFractional(percentAndSum.Item2)" />
        }
        if (vats.Count > 1)
        {
            <pair left="Sales tax" right="$@FormatMoneyFractional(vatSum)" />
        }
    }
    else
    {
         <pair left="Sales tax" right="$@FormatMoneyFractional(0)" />
    }
}

@helper Payments(IChequeTask chequeTask, IOrder order)
{
    <line />
    foreach (var prepayItem in chequeTask.Prepayments)
    {
        if (!string.IsNullOrWhiteSpace(prepayItem.CurrencyName))
        {
            <pair left="@string.Format(Resources.PrepayTemplate, prepayItem.PaymentTypeName)"
                  right="$@string.Format(Resources.CurrencyFormat, prepayItem.CurrencyName, FormatMoney(prepayItem.SumInCurrency, prepayItem.CurrencyName))" />
        }
        else
        {
            <pair left="@string.Format(Resources.PrepayTemplate, prepayItem.PaymentTypeName)"
                  right="$@FormatMoney(prepayItem.Sum)" />
        }
    }

    if (!chequeTask.CashPayments.IsEmpty() || (chequeTask.CardPayments.IsEmpty() && chequeTask.AdditionalPayments.IsEmpty()))
    {
        if (chequeTask.CashPayments.Any(p => !string.IsNullOrWhiteSpace(p.CurrencyName)) && !chequeTask.IsStorno)
        {
            foreach (var cashPaymentItem in chequeTask.CashPayments)
            {
                if (!string.IsNullOrWhiteSpace(cashPaymentItem.CurrencyName))
                {
                    <pair left="@cashPaymentItem.PaymentTypeName"
                          right="$@string.Format(Resources.CurrencyFormat, cashPaymentItem.CurrencyName, FormatMoney(SetSign(cashPaymentItem.SumInCurrency), cashPaymentItem.CurrencyName))" />

                    var currency = Model.Order.FixedCurrencyRates.Keys.SingleOrDefault(r => r.IsoName.Equals(cashPaymentItem.CurrencyName));
                    if (currency != null)
                    {
                        var rate = Model.Order.FixedCurrencyRates[currency];
                        <right>@string.Format(Resources.CurrencyRateFormat, currency.IsoName, rate.ToString("f4", CultureInfo.CurrentCulture), Model.CommonInfo.CafeSetup.CurrencyIsoName)</right>
                    }
                }
                else
                {
                    <pair left="@cashPaymentItem.PaymentTypeName"
                          right="$@string.Format(Resources.CurrencyFormat, Model.CommonInfo.CafeSetup.CurrencyIsoName, FormatMoney(SetSign(cashPaymentItem.Sum)))" />
                }
            }
        }
        else
        {
            @Payment(Resources.Cash, chequeTask.CashPayment)
        }
    }
    foreach (var cardPaymentItem in chequeTask.CardPayments)
    {
        paymentsTypesName.Add(cardPaymentItem.PaymentTypeName);
        @Payment(string.Format(Resources.CardPattern, cardPaymentItem.PaymentTypeName), cardPaymentItem.Sum, cardPaymentItem.Comment)
    }
    foreach (var additionalPaymentItem in chequeTask.AdditionalPayments)
    {
        @Payment(additionalPaymentItem.PaymentTypeName, additionalPaymentItem.Sum, additionalPaymentItem.Comment)
    }

    var orderPaymentsSumWithoutPrepay = chequeTask.CashPayment + chequeTask.CardPayments.Sum(p => p.Sum) + chequeTask.AdditionalPayments.Sum(p => p.Sum);
    var orderPaymentsSumWithPrepay = orderPaymentsSumWithoutPrepay + SetSign(chequeTask.Prepayments.Sum(p => p.Sum));
    var changeSum = Math.Max(orderPaymentsSumWithPrepay - chequeTask.ResultSum, 0m);

    var hasMultiplePayments = ((chequeTask.CashPayment != 0m ? 1 : 0) +
                                chequeTask.CardPayments.Count() +
                                chequeTask.AdditionalPayments.Count() +
                                chequeTask.Prepayments.Count()) > 1;

    if (hasMultiplePayments)
    {
        <pair left="@Resources.Total" right="$@FormatMoney(SetSign(orderPaymentsSumWithoutPrepay))" />
    }
    
    if (changeSum > 0m)
    {
        <pair left="@Resources.Change" right="$@FormatMoney(changeSum)" />
    }
var paymentsSum = 0m;
  foreach (var prepay in order.PrePayments)
    {
         paymentsSum += prepay.Sum;    
         <pair left="@string.Format(Resources.PrepayTemplate, prepay.Type.Name)" right="$@FormatMoney(prepay.Sum)" />
    }
    foreach (var payment in order.Payments)
    {
         paymentsSum += payment.Sum;
        <pair left="@payment.Type.Name" right="$@FormatMoney(payment.Sum)" />
    }
    <pair left="TOTAL DUE:" right="$@FormatMoney(chequeTask.ResultSum - paymentsSum)" />

    var tipsIncludedInExtensions = Model.Extensions.BeforeCheque != null && Model.Extensions.BeforeCheque.Any(x => x != null && x.ToString().ToLower().Contains("tips")) ||  Model.Extensions.AfterCheque != null && Model.Extensions.AfterCheque.Any(x => x != null && x.ToString().ToLower().Contains("tips"));

     if(!tipsIncludedInExtensions && Model.Order.Donations != null && Model.Order.Donations.Where(x => x.Status.ToString() == "Processed" || x.Status.ToString() == "Printed").Count() > 0)
    {
      <line />
        var tipsSum = Model.Order.Donations.Where(x => x.Status.ToString() == "Processed" || x.Status.ToString() == "Printed").Sum(x=> x.Sum);
        <pair left="TIP AMT:" right="$@FormatMoney(SetSign(tipsSum))" />
        <pair left="TOTAL AMT:" right="$@FormatMoney(chequeTask.ResultSum + tipsSum)" />
    }
}

@helper Payment(string name, decimal sum, string comment = null)
{
    <pair left="@name" right="$@FormatMoney(SetSign(sum))" />
    if (!string.IsNullOrWhiteSpace(comment))
    {
        <left>@comment</left>
    }
}

@functions
{

    public static List<string> paymentsTypesName = new List<string>();
    private decimal SetSign(decimal sum)
    {
        return Model.ChequeTask.IsStorno ? -sum : sum;
    }
      private static bool CommonModifiersFilter(bool isCommonModifier, IProductItem parent, bool onlyCommonModifiers)
    {
        if (parent.CompoundsInfo != null && parent.CompoundsInfo.IsPrimaryComponent)
        {
            if (onlyCommonModifiers && !isCommonModifier)
                return false;
            if (!onlyCommonModifiers && isCommonModifier)
                return false;
            return true;
        }
        return true;
    }

    private static bool ModifiersFilter(IOrderEntry orderEntry, IOrderItem parent, bool onlyCommonModifiers = false)
    {
        var parentProductItem = parent as IProductItem;
        if (parentProductItem != null && !CommonModifiersFilter(((IModifierEntry)orderEntry).IsCommonModifier, parentProductItem, onlyCommonModifiers))
            return false;

        if (orderEntry.Cost > 0m)
            return true;

        if (!orderEntry.Product.PrechequePrintable)
            return false;

        var modifierEntry = orderEntry as IModifierEntry;
        if (modifierEntry == null)
            return true;

        if (modifierEntry.ChildModifier == null)
            return true;

        if (!modifierEntry.ChildModifier.HideIfDefaultAmount)
            return true;

        var amountPerItem = modifierEntry.ChildModifier.AmountIndependentOfParentAmount
            ? modifierEntry.Amount
            : modifierEntry.Amount / GetParentAmount(parent, onlyCommonModifiers);

        return amountPerItem != modifierEntry.ChildModifier.DefaultAmount;
    }

    private static decimal GetParentAmount(IOrderItem parent, bool onlyCommonModifiers)
    {
        return onlyCommonModifiers ? parent.Amount * 2 : parent.Amount;
    }
     private static string GetOrderEntryNameWithProductSize(IOrderEntry orderEntry)
    {
        var productItem = orderEntry as IProductItem;
        return productItem == null || productItem.ProductSize == null || productItem.CompoundsInfo != null
            ? orderEntry.Product.Name
            : string.Format(Resources.ProductNameWithSizeFormat, productItem.Product.Name, productItem.ProductSize.Name);
    }
}