@using System.Linq
@using Resto.Front.PrintTemplates.Cheques.Razor
@using Resto.Front.PrintTemplates.Cheques.Razor.TemplateModels
@using Resto.Front.PrintTemplates.RmsEntityWrappers

@inherits TemplateBase<ICookingCompleteCheque>


            
@{
    var order = Model.Order;

    IKitchenOrderProductItem productItem;
    IKitchenOrderProductItem compoundItemSecondaryComponent = null;
    IKitchenOrderModifierItem modifierItem;

    if (Model.Item is IKitchenOrderProductItem)
    {
        productItem = (IKitchenOrderProductItem)Model.Item;
        if (Model.CompoundItemSecondaryComponent != null)
        {
            compoundItemSecondaryComponent = Model.CompoundItemSecondaryComponent;
        }
        modifierItem = null;
    }
    else
    {
        modifierItem = (IKitchenOrderModifierItem)Model.Item;
        productItem = order.Items.Single(item => item.Modifiers.Contains(modifierItem));
    }

    var course = productItem.Course;
}


@if(Model.Order.Type != null && Model.Order.Type.Name == "DINE-IN"){
<doc bell="" formatter="split">
    <center><f2>@Model.Order.Type.Name №@order.Number</f2></center>
    <np />
    @string.Format(Resources.KitchenHeaderPattern, FormatFullDateTime(Model.CommonInfo.CurrentTime), order.Number, 1, order.Waiter.GetNameOrEmpty())
    <np />
<np />
<np />
    <f1><np /></f1>
    @if (course != 1)
    {
        <f1>@GetCourseTitle(course)</f1>
    }
    @if (modifierItem == null)
    {
        @ProductTable(productItem)
        if (HasModifiersToPrint(productItem))
        {
            @ModifiersTable(productItem)
        }
        if (compoundItemSecondaryComponent != null)
        {
            @ProductTable(compoundItemSecondaryComponent)
            if (HasModifiersToPrint(productItem))
            {
                @ModifiersTable(compoundItemSecondaryComponent)
            }
        }
        
        if (Model.CookingPlace.PrintKitchenBarcodeType != PrintKitchenBarcodeType.Never)
        {
            <np/>
            <center><barcode>@productItem.ServiceChequeBarcode</barcode></center>
        }
    }
    else
    {
        @ModifierProductTable(modifierItem)
    }
    <np />
    <np />
</doc>
}
else
{
<doc>
</doc>
}

@helper ProductTable(IKitchenOrderProductItem product)
{
    if (product.CompoundsInfo != null && product.CompoundsInfo.IsPrimaryComponent)
    {
        <f1>
            <table>
                <columns>
                    @TableColumns()
                </columns>
                <cells>
                    <c>@FormatAmount(product.Amount * 2)</c>
                    <ct>@string.Format("{0} {1}", product.CompoundsInfo.ModifierSchemaName, product.ProductSize == null ? string.Empty : product.ProductSize.Name)</ct>
                    
                </cells>
            </table>
        </f1>
        @ModifiersTable(product, true)
    }
    var componentString = string.Empty;
    if (product.CompoundsInfo != null)
    {
        componentString = " 1/2 ";
    }
    <f1>
        <table>
            <columns>
                @TableColumns()
            </columns>
            <cells>

                @if (product.CompoundsInfo == null)
                {
                    <c>@FormatAmount(product.Amount)</c>
                }
                else
                {
                    <c />
                }
                 <ct>
                    <whitespace-preserve>@(Model.CookingPlace == product.Kitchen
                        ? componentString + GetProductKitchenNameWithSize(product)
                        : componentString + string.Format(Resources.CookingPlaceTemplate, product.Kitchen.Name, GetProductKitchenNameWithSize(product)))</whitespace-preserve>
                </ct>
            </cells>
        </table>
    </f1>
}

@helper ModifierProductTable(IKitchenOrderModifierItem modifier)
{
    <f1>
        <table>
            <columns>
                @TableColumns()
            </columns>
            <cells>                
                <c>@FormatAmount(modifier.Amount)</c>
                <ct>
                    @(Model.CookingPlace == modifier.Kitchen
                          ? modifier.Product.GetKitchenOrDefaultName()
                          : string.Format(Resources.CookingPlaceTemplate, modifier.Kitchen.Name, modifier.Product.GetKitchenOrDefaultName()))
                </ct>
            </cells>
        </table>
    </f1>
}

@helper ModifiersTable(IKitchenOrderProductItem productItem, bool onlyCommonModifiers = false)
{
    var commentText = productItem.Comment != null && !productItem.Comment.Deleted ? productItem.Comment.Text : null;
    var modifiers = productItem.Modifiers.Where(m =>
        CommonModifiersFilter(m.IsCommonModifier, productItem, onlyCommonModifiers) &&
        !m.Deleted && !m.IsHidden).ToList();
    var productsOfZeroAmountModifiers = productItem.CompoundsInfo == null 
        ? productItem.ProductsOfZeroAmountCommonModifiers.Concat(productItem.ProductsOfZeroAmountModifiers)
        : productItem.CompoundsInfo.IsPrimaryComponent && onlyCommonModifiers
            ? productItem.ProductsOfZeroAmountCommonModifiers
            : productItem.ProductsOfZeroAmountModifiers;
    
    <f0>
        <table>
            <columns>
                <column autowidth="" minwidth="2"/>
                @TableColumns()
            </columns>
            <cells>
                @if (commentText != null)
                {
                    <ct />
                    <c>@commentText</c>
                    <ct />
                }

                @{
                    var parentAmount = GetParentAmount(productItem, onlyCommonModifiers);
                    foreach (var modifier in modifiers)
                    {
                        <ct />
                        <c>
                            @(modifier.AmountIndependentOfParentAmount
                                  ? string.Format(Resources.KitchenModifierAbsoluteAmountPattern, modifier.Amount)
                                  : string.Format(Resources.KitchenModifierAmountPattern, (int)(modifier.Amount / parentAmount)))
                        </c>
                        <ct>
                            @(Model.CookingPlace == modifier.Kitchen
                                  ? modifier.Product.GetKitchenOrDefaultName()
                                  : string.Format(Resources.CookingPlaceTemplate, modifier.Kitchen.Name, modifier.Product.GetKitchenOrDefaultName()))
                        </ct>
                    }
                }

                @foreach (var product in productsOfZeroAmountModifiers)
                {
                    <ct />
                    <c>@string.Format(Resources.KitchenModifierAmountPattern, 0m)</c>
                    <ct>
                        @(Model.CookingPlace == productItem.Kitchen
                              ? product.GetKitchenOrDefaultName()
                              : string.Format(Resources.CookingPlaceTemplate, productItem.Kitchen.Name, product.GetKitchenOrDefaultName()))
                    </ct>      
                }
            </cells>
        </table>
    </f0>
}

@helper TableColumns()
{
    <column formatter="split" />
    <column autowidth="" />
}

@functions
{
    private static string GetCourseTitle(int course)
    {
        switch (course)
        {
            case 0:
                return Resources.KitchenCourseVipTitle;
            case 1:
                return Resources.KitchenCourse1Title;
            case 2:
                return Resources.KitchenCourse2Title;
            case 3:
                return Resources.KitchenCourse3Title;
            case 4:
                return Resources.KitchenCourse4Title;
            default:
                return string.Format(Resources.KitchenCourseTitleFormat, course);
        }
    }

    private static bool HasModifiersToPrint(IKitchenOrderProductItem productItem)
    {
        if (productItem.Comment != null && !productItem.Comment.Deleted)
            return true;

        if (productItem.Modifiers.Any(modifier => !modifier.Deleted && !modifier.IsHidden))
            return true;

        return productItem.ProductsOfZeroAmountModifiers.Any();
    }

    private static bool CommonModifiersFilter(bool isCommonModifier, IKitchenOrderProductItem 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 string GetProductKitchenNameWithSize(IKitchenOrderProductItem productItem)
    {
        return productItem.ProductSize == null || productItem.CompoundsInfo != null
            ? productItem.Product.GetKitchenOrDefaultName()
            : string.Format(Resources.ProductNameWithSizeFormat, productItem.Product.GetKitchenOrDefaultName(), productItem.ProductSize.Name);
    }

    private static decimal GetParentAmount(IKitchenOrderItem parent, bool onlyCommonModifiers)
    {
        return onlyCommonModifiers ? parent.Amount * 2 : parent.Amount;
    }
}