<?php

namespace App\Traits;

use App\Models\Campagne;
use App\Models\Coupon;
use App\Models\Contact;
use App\Models\Calendrier;
use App\Enums\CampaignTypes;
use App\Models\Customers;
use App\Models\PrintedCoupons;
use App\Models\Mouvement;
use App\Models\Mur;
use App\Models\Panier;
use App\Models\PanierContent;

trait CouponTrait
{
    public function getCouponsPublished(Campagne $campagne)
    {
        $coupons = $campagne->coupons()->get();

        foreach ($coupons as $key => $coupon) {
            // ---- Contrôle de la publication
            if ($coupon->coupon_published == 0) {
                $coupons->forget($key);
            }

            // ---- Contrôle la date de début de diffusion
            if ($coupon->coupon_mindatediffusion != null) {
                if (strtotime(date('Y-m-d')) < strtotime($coupon->coupon_mindatediffusion)) {
                    $coupons->forget($key);
                }
            }

            // ---- Contrôle la date de validité
            if ($coupon->coupon_maxdatediffusion != null) {
                if (strtotime(date('Y-m-d')) > strtotime($coupon->coupon_maxdatediffusion)) {
                    $coupons->forget($key);
                }
            }

            // ---- Contrôle des calendriers de diffusion
            $calendars = Calendrier::where(['calendrier_couponId' => $coupon->coupon_id])->get();
            if (isset($calendars) && !$calendars->isEmpty()) {
                $pub = false;
                foreach ($calendars as $calendar) {
                    if ($calendar->isPublished()) {
                        $pub = true;
                    }
                }
                if (!$pub) {
                    $coupons->forget($key);
                }
            }
        }//end foreach

        return $coupons;
    }

    public function getPanierContentPublished(Panier $panier)
    {
        $panierContents = $panier->panierContents()->get();
        foreach ($panierContents as $key => $panierContent) {
            $coupon = Coupon::where(['coupon_id' => $panierContent->panier_content_couponId])->first();
            // ---- Contrôle de la publication
            if ($coupon->coupon_published == 0) {
                $panierContents->forget($key);
            }

            // ---- Contrôle la date de début de diffusion
            if ($coupon->coupon_mindatediffusion != null) {
                if (strtotime(date('Y-m-d')) < strtotime($coupon->coupon_mindatediffusion)) {
                    $panierContents->forget($key);
                }
            }
            // ---- Contrôle la date de validité
            if ($coupon->coupon_maxdatediffusion != null) {
                if (strtotime(date('Y-m-d')) > strtotime($coupon->coupon_maxdatediffusion)) {
                    $panierContents->forget($key);
                }
            }

            // ---- Contrôle des calendriers de diffusion
            $calendars = Calendrier::where(['calendrier_couponId' => $coupon->coupon_id])->get();
            if (isset($calendars) && !$calendars->isEmpty()) {
                $pub = false;
                foreach ($calendars as $calendar) {
                    if ($calendar->isPublished()) {
                        $pub = true;
                    }
                }
                if (!$pub) {
                    $panierContents->forget($key);
                }
            }
        }//end foreach

        return $panierContents;
    }

    public function getCountCouponsPanierPublished(Panier $panier)
    {
        $panierContents = $panier->panierContents()->get();
        foreach ($panierContents as $key => $panierContent) {
            $coupon = Coupon::where(['coupon_id' => $panierContent->panier_content_couponId])->firstOrFail();
            // ---- Contrôle de la publication
            if ($coupon->coupon_published == 0) {
                $panierContents->forget($key);
            }

            // ---- Contrôle la date de début de diffusion
            if ($coupon->coupon_mindatediffusion != null) {
                if (strtotime(date('Y-m-d')) < strtotime($coupon->coupon_mindatediffusion)) {
                    $panierContents->forget($key);
                }
            }

            // ---- Contrôle la date de validité
            if ($coupon->coupon_maxdatediffusion != null) {
                if (strtotime(date('Y-m-d')) > strtotime($coupon->coupon_maxdatediffusion)) {
                    $panierContents->forget($key);
                }
            }

            // ---- Contrôle des calendriers de diffusion
            $calendars = Calendrier::where(['calendrier_couponId' => $coupon->coupon_id])->get();
            if (isset($calendars) && !$calendars->isEmpty()) {
                $pub = false;
                foreach ($calendars as $calendar) {
                    if ($calendar->isPublished()) {
                        $pub = true;
                    }
                }
                if (!$pub) {
                    $panierContents->forget($key);
                }
            }
        }//end foreach

        $count = 0;

        foreach ($panierContents as $panierContent) {
            $count = $count + $panierContent->panier_content_quantity;
        }

        return $count;
    }

    public function isAvailableToPrint(Coupon $coupon, Campagne $campagne)
    {
        /**
         * Contrôle de la publication de la campagne
         */
        if ($campagne->camp_published === 0) {
            return false;
        }

        // ---- Contrôle de la publication du coupon
        if ($coupon->coupon_published === 0) {
            return false;
        }

        // ---- Contrôle la date de début de diffusion
        if ($coupon->coupon_mindatediffusion !== null) {
            if (strtotime(date('Y-m-d')) < strtotime($coupon->coupon_mindatediffusion)) {
                return false;
            }
        }
        // ---- Contrôle la date de validité
        if ($coupon->coupon_maxdatediffusion !== null) {
            if (strtotime(date('Y-m-d')) > strtotime($coupon->coupon_maxdatediffusion)) {
                return false;
            }
        }

        // ---- Contrôle des calendriers de diffusion
        $calendars = Calendrier::where(['calendrier_couponId' => $coupon->coupon_id])->get();
        if (isset($calendars) && !$calendars->isEmpty()) {
            $pub = false;
            foreach ($calendars as $calendar) {
                if ($calendar->isPublished()) {
                    $pub = true;
                }
            }
            if (!$pub) {
                return false;
            }
        }

        return true;
    }

    public function isPausedToPrint(Coupon $coupon, Campagne $campagne)
    {
        // ---- Contrôle la date de début de diffusion
        if ($coupon->coupon_mindatediffusion !== null) {
            if (strtotime(date('Y-m-d')) < strtotime($coupon->coupon_mindatediffusion)) {
                return false;
            }
        }
        // ---- Contrôle la date de validité
        if ($coupon->coupon_maxdatediffusion !== null) {
            if (strtotime(date('Y-m-d')) > strtotime($coupon->coupon_maxdatediffusion)) {
                return false;
            }
        }

        // ---- Contrôle des calendriers de diffusion
        $calendars = Calendrier::where(['calendrier_couponId' => $coupon->coupon_id])->get();
        if (isset($calendars) && !$calendars->isEmpty()) {
            $pub = false;
            foreach ($calendars as $calendar) {
                if ($calendar->isPublished()) {
                    $pub = true;
                }
            }
            if (!$pub) {
                return false;
            }
        }

        return true;
    }


    public function isAvailable(Coupon $coupon, Campagne $campagne, Contact $contact)
    {
        $available = true;

        // ---- Contrôle le nombre limite d'impression
        if ($coupon->coupon_enablelimitquantity == 1 && $coupon->coupon_enablelimitquantity > 0) {
            $stat = Mur::where([
                'mur_campId' => $campagne->camp_id,
                'mur_contactId' => $contact->contact_id,
                'mur_couponId' => $coupon->coupon_id,
                'mur_deleted' => 0 ])
                ->count();

            if ($stat >= $coupon->coupon_limitquantity) {
                $available = false;
            }
        }

        // ---- Contrôle la limite de période de diffusion
        if ($coupon->coupon_enablelimitperiod == 1 && $coupon->coupon_limitperiod > 0) {
            $stat = Mur::where([
                'mur_campId' => $campagne->camp_id,
                'mur_contactId' => $contact->contact_id,
                'mur_couponId' => $coupon->coupon_id,
                'mur_deleted' => 0 ])
                ->orderBy('mur_createdate', 'DESC')
                ->first();

            if (isset($stat) && $stat->count() > 0) {
                $dateDisponibilite = date('Y-m-d', strtotime($stat->mur_createdate . " +" . $coupon->coupon_limitperiod . " days"));
                if ($dateDisponibilite > date('Y-m-d')) {
                    $available = false;
                }
            }
        }

        return $available;
    }

    public function getFullQuantity(Coupon $coupon)
    {
        return (int)Mouvement::where('mouvement_couponId', $coupon->coupon_id)->sum('mouvement_nombre');
    }

    public function getUsedQuantity(Coupon $coupon)
    {
        $countPrinted = 0;
        foreach ($coupon->campagnes as $campagne) {
            if ($campagne->camp_type->equals(CampaignTypes::mur()) || $campagne->camp_type->equals(CampaignTypes::murss())) {
                // Murs
                $murs = Mur::where(['mur_campid' => $campagne->camp_id, 'mur_couponId' => $coupon->coupon_id])->count();
                $countPrinted += $murs;
            } else {
                // Paniers
                // TODO : Revoir la requete
                $campagneId = $campagne->camp_id;
                $countPrinted = PanierContent::where('panier_content_couponId', $coupon->coupon_id)->whereHas('panier', function ($query) use ($campagneId) {
                    $query->where('panier_campId', $campagneId);
                })->sum('panier_content_printed');
            }
        }
        return $countPrinted;
    }

    public function getDiffusedQuantity(Coupon $coupon)
    {
        $countPrinted = 0;
        foreach ($coupon->campagnes as $campagne) {
            if ($campagne->camp_type->equals(CampaignTypes::mur()) || $campagne->camp_type->equals(CampaignTypes::murss())) {
                // Murs
                $murs = Mur::where(['mur_campid' => $campagne->camp_id, 'mur_couponId' => $coupon->coupon_id])->count();
                $countPrinted += $murs;
            } else {
                // Paniers
                $campagneId                 = $campagne->camp_id;
                $panierContents = PanierContent::where('panier_content_couponId', $coupon->coupon_id)->whereHas('panier', function ($query) use ($campagneId) {
                    $query->where('panier_campId', $campagneId);
                })->get();
                $panierContentCountPrinted  = $panierContents->sum('panier_content_printed');
                $panierContentCountDiffused = $panierContents->sum('panier_content_quantity');
                $countPrinted               = $countPrinted + $panierContentCountPrinted + $panierContentCountDiffused;
            }
        }
        return $countPrinted;
    }

    public function getUsedQuantityOnPeriod(Coupon $coupon, $startdate, $enddate)
    {
        $countPrinted = 0;
        $startdate    = date('Y-m-d H:i:s', strtotime($startdate));
        $enddate      = date('Y-m-d H:i:s', strtotime($enddate));
        $campagnes    = $coupon->campagnes()->get();
        foreach ($campagnes as $campagne) {
            if ($campagne->camp_type->equals(CampaignTypes::mur()) || $campagne->camp_type->equals(CampaignTypes::murss())) {
// Murs
                $murs         = Mur::where(['mur_campid' => $campagne->camp_id, 'mur_couponId' => $coupon->coupon_id])->whereBetween('mur_createdate', [$startdate, $enddate])->get();
                $countPrinted = $countPrinted + count($murs);
            } else {
// Paniers
                $paniers = Panier::where(['panier_campId' => $campagne->camp_id])->where(function ($query) use ($startdate, $enddate) {
                    $query->whereBetween('panier_createdate', [$startdate, $enddate])
                        ->orWhereBetween('panier_updatedate', [$startdate, $enddate]);
                })->get();
                foreach ($paniers as $key => $panier) {
                    $panierContentCount = $panier->panierContents->sum('panier_content_printed');
                    $countPrinted       = $countPrinted + $panierContentCount;
                }
            }
        }
        return $countPrinted;
    }
    // VB 22/04/2021
    public function isUsed(Coupon $coupon, Campagne $campagne, Customers $customer)
    {
        $isUsed = false;

        // ---- Contrôle le nombre limite d'impression
        if ($coupon->coupon_enablelimitquantity === 1) {
            $count = PrintedCoupons::where(
                [
                    ['camp_id', '=', $campagne->camp_id],
                    ['coupon_id', '=', $coupon->coupon_id],
                    ['customer_id', '=', $customer->id]
                ]
            )->count();

            if ($count >= $coupon->coupon_limitquantity) {
                $isUsed = true;
            }
        }

        // ---- Contrôle la limite de période de diffusion
        if ($coupon->coupon_enablelimitperiod === 1 && $coupon->coupon_limitperiod > 0) {
            $count = PrintedCoupons::where(
                [
                    ['camp_id', '=', $campagne->camp_id],
                    ['coupon_id', '=', $coupon->coupon_id],
                    ['customer_id', '=', $customer->id]
                ]
            )->orderBy('created_at', 'DESC')->first();

            if ($count && $count->count() > 0) {
                $date = date('Y-m-d', strtotime($count->created_at . " +" . $coupon->coupon_limitperiod . " days"));
                if ($date > date('Y-m-d')) {
                    $isUsed = true;
                }
            }
        }
        return $isUsed;
    }
}