<?php

namespace App\Http\Controllers\Web;


use Yard;
use Request;
use App\User;
use Validator;
use App\Services\Shop;
use App\Services\Util;
use App\Models\Homeparty;
use App\Services\Payment;
use App\Services\AboHelper;
use App\Models\ShoppingUser;
use App\Models\PaymentMethod;
use App\Models\ShoppingOrder;
use App\Models\ShippingCountry;
use App\Models\ShoppingPayment;
use App\Models\ShoppingOrderItem;
use App\Models\PaymentTransaction;
use App\Services\CustomerPriority;
use Illuminate\Support\Collection;
use App\Http\Controllers\Controller;
use App\Models\ShoppingCollectOrder;
use Illuminate\Session\SessionManager;
use App\Http\Controllers\Pay\PayoneController;

class CheckoutController extends Controller
{
    private $session;
    private $instance;
    /**
     * Create a new controller instance.
     *
     * @return void
     */
    public function __construct(SessionManager $session)
    {
        $this->session = $session;
        $this->instance = sprintf('%s.%s', 'cart', 'payments');
    }


    public function checkout(){

       // dump(Request::all());
//        $user_shop = Util::getUserShop();
         $shopping_data = Yard::instance('shopping')->getYardExtra('shopping_data');

         $is_from =  isset($shopping_data['is_from']) ? $shopping_data['is_from'] : 'shopping';
         $is_for = isset($shopping_data['is_for']) ? $shopping_data['is_for'] : false;
         $is_abo = isset($shopping_data['is_abo']) ? (bool) $shopping_data['is_abo'] : false;
         $abo_interval = isset($shopping_data['abo_interval']) ? $shopping_data['abo_interval'] : 0;
         if($is_for === 'ot-customer' || $is_for === 'abo-ot-customer'){
            $is_from = 'shopping';
         }
         $homeparty_id = isset($shopping_data['homeparty_id']) ? $shopping_data['homeparty_id'] : null;
         $shopping_user = null;
        
        if(\Session::has('new_session')){
            $this->destroy();
            \Session::forget('new_session');
        }
        
        if(!$this->getPayments('shopping_user_id')){
              if($shopping_data && $is_from !== 'shopping'){
                  //can  wizard membership user_order 
                  //$shopping_user_id = isset($shopping_data['shopping_user_id']) ? $shopping_data['shopping_user_id'] : false;
                  $shopping_user = $this->shoppingUserAuthData($is_from, $is_for, $shopping_data);
                  $shopping_user->save();
                  $this->putPayments('shopping_user_id', $shopping_user->id);
              }elseif($is_from === 'shopping' && ($is_for !== 'ot-customer' || $is_for !== 'abo-ot-customer')){
                  $shopping_user = new ShoppingUser();
                  $shopping_user->is_for = $is_for;
                  $shopping_user->is_from = $is_from;
                  $shopping_user->homeparty_id = $homeparty_id;
                  $shopping_user->mode = 'prev';
                  $shopping_user->language = \App::getLocale();
              }elseif($is_from === 'shopping' && ($is_for === 'ot-customer' || $is_for === 'abo-ot-customer')){
                 $shopping_user = $this->makeCustomerShoppingUser($shopping_data);
                 $shopping_user->is_for = $is_for;
                 $shopping_user->is_from = $is_from;
                 $shopping_user->mode = 'prev';
                 $shopping_user->language = \App::getLocale();
              }
        }else{
            $shopping_user = ShoppingUser::findOrFail($this->getPayments('shopping_user_id'));
            $shopping_user->billing_state = Shop::getCountryShippingCountryId($shopping_user->billing_country_id);
            $shopping_user->shipping_state = Shop::getCountryShippingCountryId($shopping_user->shipping_country_id);
            $shopping_user->same_as_billing = $shopping_user->same_as_billing ? false : true; //reinvert
        }
        if($shopping_user->same_as_billing === NULL){
            $shopping_user->same_as_billing = false;
        }

        if(!$shopping_user->billing_country){
            $shopping_user->billing_country = Yard::instance('shopping')->getUserCountry();
        }
        if(!$shopping_user->shipping_country){
            $shopping_user->shipping_country = Yard::instance('shopping')->getUserCountry();
        }

        if(old('selected_country') && old('selected_country') === 'change'){
            \Session::forget('_old_input.selected_country');
            $shopping_user->billing_state = old('billing_state');
            $shopping_user->shipping_state = old('shipping_state');
        }else{
            $shopping_user->billing_state = Yard::instance('shopping')->getShippingCountryId();
            $shopping_user->shipping_state = Yard::instance('shopping')->getShippingCountryId();
        }
        $payment_methods = $this->getPaymentsMethods($is_from, $is_abo);
        $data = [
            'is_from' => $is_from,
            'is_for' => $is_for,
            'is_abo' => $is_abo,
            'abo_interval' => $abo_interval,
            'shopping_data' => $shopping_data,
            'user_shop' => Util::getUserShop(),
            'shopping_user' => $shopping_user,
            'shopping_mode' => Util::getUserShoppingMode(),
            'payment_methods' => $payment_methods['default'],
            'payment_methods_active' => $payment_methods['active'],
            'payment_data' => $payment_methods['data'],
        ];
        return view('web.templates.checkout', $data);
    }

    private function getPaymentsMethods($is_from, $is_abo = false){
        $payment_methods = [];
        if($is_from !== 'shopping' && Util::getAuthUser()){
            $user = Util::getAuthUser();
            $payment_methods['default'] = $user->payment_methods;
            $payment_methods['data'] = $user->account->payment_data;
        }else{
            $payment_methods['default'] = PaymentMethod::getDefaultAsArray($is_abo)->toArray();
            $payment_methods['data'] = false;
        }
        if($is_abo){
            $payment_methods['active'] = \App\Models\PaymentMethod::where('active', true)->where('is_abo', true)->get()->pluck( 'id', 'short')->toArray();
        }else{
            $payment_methods['active'] = \App\Models\PaymentMethod::where('active', true)->get()->pluck( 'id', 'short')->toArray();
        }
        return $payment_methods;
    }

    private function isPaymentsMethodsActive($payment_method, $is_from, $is_abo = false){
        $payment_names = ['wlt#PPE' => 'PP', 'cc' => 'CC', 'sb#PNT' => 'SB', 'elv' => 'SEPA', 'vor' => 'VOR', 'fnc#MIV' => 'FNC'];
        $payment_methods = $this->getPaymentsMethods($is_from, $is_abo);
        if(isset($payment_names[$payment_method])){
            $payment_with = $payment_names[$payment_method];
            if(array_key_exists($payment_with, $payment_methods['active']) && in_array($payment_methods['active'][$payment_with], $payment_methods['default'])){
               return true;
            }
        }
        abort(404);
    }

    private function shoppingUserAuthData($is_from, $is_for, $data = []){

        $user = Util::getAuthUser();
        $shopping_user = new ShoppingUser();
        $shopping_user->auth_user_id = $user->id;
        $shopping_user->mode = 'prev';
        $shopping_user->language = \App::getLocale();
        
        $shopping_user->billing_salutation = $user->account->salutation;
        $shopping_user->billing_company = $user->account->company;
        $shopping_user->billing_firstname = $user->account->first_name;
        $shopping_user->billing_lastname = $user->account->last_name;
        $shopping_user->billing_address = $user->account->address;
        $shopping_user->billing_address_2 = $user->account->address_2;
        $shopping_user->billing_zipcode = $user->account->zipcode;
        $shopping_user->billing_city = $user->account->city;
        $shopping_user->billing_country_id = $user->account->country_id;
        $shopping_user->billing_phone = $user->account->phone;
        $shopping_user->billing_email = $user->email;
        $shopping_user->faker_mail = false;
        $shopping_user->shipping_email = $user->email;

        $shopping_user->accepted_data_checkbox = 1;
        $shopping_user->is_for = $is_for;
        $shopping_user->is_from = $is_from;
        $shopping_user->homeparty_id = isset($data['homeparty_id']) ? $data['homeparty_id'] : null;
        $shopping_user->shopping_collect_order_id = isset($data['shopping_collect_order_id']) ? $data['shopping_collect_order_id'] : null;

        //Lieferadresse
        if($is_from === 'user_order'){
            if(isset($data['shopping_user_id']) && strpos($data['is_for'], 'ot') !== false){
                $s_user = ShoppingUser::findOrFail($data['shopping_user_id']);
              /*  $shopping_user->billing_salutation = $s_user->billing_salutation;
                $shopping_user->billing_company = $s_user->billing_company;
                $shopping_user->billing_firstname = $s_user->billing_firstname;
                $shopping_user->billing_lastname = $s_user->billing_lastname;
                $shopping_user->billing_address = $s_user->billing_address;
                $shopping_user->billing_address_2 = $s_user->billing_address_2;
                $shopping_user->billing_zipcode = $s_user->billing_zipcode;
                $shopping_user->billing_city = $s_user->billing_city;
                $shopping_user->billing_country_id = $s_user->billing_country_id;
                $shopping_user->billing_phone = $s_user->billing_phone;
                $shopping_user->billing_email = $s_user->billing_email;
                ;*/
                $shopping_user->faker_mail = $s_user->faker_mail;
                if(!$s_user->faker_mail){
                    $shopping_user->shipping_email = $s_user->billing_email;
                }
                $shopping_user->shopping_user_id = $data['shopping_user_id'];
                $shopping_user->member_id = $s_user->member_id;
            }
            $shopping_user->same_as_billing = true;
            $shopping_user->shipping_salutation = isset($data['shipping_salutation']) ? $data['shipping_salutation'] : '';
            $shopping_user->shipping_company = isset($data['shipping_company']) ? $data['shipping_company'] : '';
            $shopping_user->shipping_firstname = isset($data['shipping_firstname']) ? $data['shipping_firstname'] : '';
            $shopping_user->shipping_lastname = isset($data['shipping_lastname']) ? $data['shipping_lastname'] : '';
            $shopping_user->shipping_address = isset($data['shipping_address']) ? $data['shipping_address'] : '';
            $shopping_user->shipping_address_2 = isset($data['shipping_address_2']) ? $data['shipping_address_2'] : '';
            $shopping_user->shipping_zipcode = isset($data['shipping_zipcode']) ? $data['shipping_zipcode'] : '';
            $shopping_user->shipping_city = isset($data['shipping_city']) ? $data['shipping_city'] : '';
            $shopping_user->shipping_country_id = Yard::instance('shopping')->getShippingCountryCountryId();
            $shopping_user->shipping_phone = isset($data['shipping_phone']) ? $data['shipping_phone'] : '';

        }else{
            $shopping_user->same_as_billing = $user->account->same_as_billing ? false : true;
            $shopping_user->shipping_salutation = $user->account->shipping_salutation;
            $shopping_user->shipping_company = $user->account->shipping_company;
            $shopping_user->shipping_firstname = $user->account->shipping_firstname;
            $shopping_user->shipping_lastname = $user->account->shipping_lastname;
            $shopping_user->shipping_address = $user->account->shipping_address;
            $shopping_user->shipping_address_2 = $user->account->shipping_address_2;
            $shopping_user->shipping_zipcode = $user->account->shipping_zipcode;
            $shopping_user->shipping_city = $user->account->shipping_city;
            $shopping_user->shipping_country_id = $user->account->shipping_country_id;
            $shopping_user->shipping_phone = $user->account->shipping_phone;
        }

        return $shopping_user;
    }

    public function checkoutFinal(){

        $data = Request::all();
        if(isset($data['payment_method'])){
            $this->isPaymentsMethodsActive($data['payment_method'], $data['is_from'], $data['is_abo']);
        }
       
        //change selected Country
        if(isset($data['selected_country']) && $data['selected_country'] === 'change'){
            if(!Request::get('same_as_billing')){
                Yard::instance('shopping')->setShippingCountryWithPrice($data['billing_state'], $data['is_for']);
            }else{
                Yard::instance('shopping')->setShippingCountryWithPrice($data['shipping_state'], $data['is_for']);
            }
            return back()->withInput(Request::all());
        }

        $rules = array(
            'billing_salutation' => 'required',
            'billing_firstname'=>'required',
            'billing_lastname'=>'required',
            'billing_email'=>'required|email',
            'billing_address'=>'required',
            'billing_zipcode'=>'required',
            'billing_city' => 'required',
            'accepted_data_checkbox' => 'accepted',
        );

        if(Request::get('same_as_billing')){
            $rules = array_merge($rules, [
                'shipping_firstname'=>'required',
                'shipping_lastname'=>'required',
                'shipping_address'=>'required',
                'shipping_zipcode'=>'required',
                'shipping_city' => 'required',
                'shipping_salutation' => 'required'

            ]);
        }
        $validator = Validator::make(Request::all(), $rules);
        if ($validator->fails()) {
            return back()->withErrors($validator)->withInput(Request::all());
        }
        $data = Request::all();
        //make User
        $shopping_user = $this->makeShoppingUser($data);

        //make Order and Items
        $shopping_order =  $this->makeShoppingOrder($shopping_user, $data);

        //delete session 
        if(\Session::has('user_shop_payment') && \Session::get('user_shop_payment') === 6){
            $user_shop_identifier = \Session::get('user_shop_identifier');
            Yard::instance('shopping')->deleteStoredCart($user_shop_identifier);
            \App\Models\ShoppingInstance::where('identifier',  $user_shop_identifier)->delete();
        }
     
        //CustomerPriority
        if($shopping_user->is_from === 'shopping'){
            $ret = CustomerPriority::checkOne(ShoppingUser::find($shopping_user->id), true);
        }
        Util::setUserHistoryValue(['status'=>2, 'shopping_order_id'=>$shopping_order->id]);

        //check credit Card
        if(Request::get('payment_method')){
            $ret = [];
            //Rechnungskauf ohne PAYONE
            if(Request::get('payment_method') === 'fnc#MIV'){

            }
            //need precheck the card
            if(Request::get('payment_method') === 'cc'){
                $pay = new PayoneController();
                $pay->init($shopping_user, $shopping_order);
                $ret['cc'] = $pay->checkCreditCard($data);
                if($ret['cc']['status'] === 'ERROR' || $ret['cc']['status'] === 'INVALID'){
                   /* PaymentTransaction::create([
                        'shopping_payment_id' => //is no shopping_payment_id at this moment,
                        'request' => 'creditcardcheck,
                        'errorcode' => $ret['cc']['errorcode'],
                        'errormessage' => $ret['cc']['errormessage'],
                        'customermessage' => $ret['cc']['customermessage'],
                        'status' => $response['status'],
                    ]);*/
                    \Session::flash('cc-error', 1);
                    \Session::flash('errormessage', $ret['cc']['errormessage']);
                    \Session::flash('customermessage', $ret['cc']['customermessage']);
                    return redirect(route('checkout.checkout_card'))->withInput(Request::all());
                }
                if($ret['cc']['status'] === 'VALID'){
                    /*
                     * array(4) { ["status"]=> string(5) "VALID" ["pseudocardpan"]=> string(19) "9410010000169020567" ["cardtype"]=> string(1) "V" ["truncatedcardpan"]=> string(16) "411111XXXXXX1111" }
                     * application through http post
                     * get this to the prepayment
                     * */
                }
            }

            //need precheck the SEPA
            if(Request::get('payment_method') === 'elv' && is_null(Request::get('mandate_identification'))){
                $pay = new PayoneController();
                $pay->init($shopping_user, $shopping_order);
                $amount = Yard::instance('shopping')->totalWithShipping(2, '.', '') * 100;
                $ret['elv'] = $pay->checkBankAccount($data, $amount, 'EUR',  $shopping_user);
                if($ret['elv']['status'] === 'ERROR' || $ret['elv']['status'] === 'INVALID'){
                    /* PaymentTransaction::create([
                         'shopping_payment_id' => //is no shopping_payment_id at this moment,
                         'request' => 'creditcardcheck,
                         'errorcode' => $ret['cc']['errorcode'],
                         'errormessage' => $ret['cc']['errormessage'],
                         'customermessage' => $ret['cc']['customermessage'],
                         'status' => $response['status'],
                     ]);*/
                    \Session::flash('elv-error', 1);
                    \Session::flash('errormessage', $ret['elv']['errormessage']);
                    \Session::flash('customermessage', $ret['elv']['customermessage']);
                    return redirect(route('checkout.checkout_card'))->withInput(Request::all());
                }
                // mandate_status active
                if($ret['elv']['status'] === 'APPROVED' && $ret['elv']['mandate_status'] !== "active"){
                    \Session::flash('elv-managemandate', 1);
                    \Session::flash('elv-mandate_identification', $ret['elv']['mandate_identification']);
                    \Session::flash('elv-mandate_text', $ret['elv']['mandate_text']);
                    \Session::flash('elv-creditor_identifier', $ret['elv']['creditor_identifier']);
                    return redirect(route('checkout.checkout_card'))->withInput(Request::all());

                    /*
                     * array(4) { ["status"]=> string(5) "VALID" ["pseudocardpan"]=> string(19) "9410010000169020567" ["cardtype"]=> string(1) "V" ["truncatedcardpan"]=> string(16) "411111XXXXXX1111" }
                     * application through http post
                     * get this to the prepayment
                     * */
                }
                $ret['elv']['bankaccountholder'] = $data['elv_bankaccountholder'];

            }
            if(Request::get('payment_method') === 'elv' && Request::get('mandate_identification')) {
                $ret['elv']['mandate_identification'] = Request::get('mandate_identification');
                $ret['elv']['creditor_identifier'] = Request::get('creditor_identifier');
                $ret['elv']['iban'] = $data['elv_iban'];
                $ret['elv']['bic'] = $data['elv_bic'];
                $ret['elv']['bankaccountholder'] = $data['elv_bankaccountholder'];
                //check abo and save the mandate
                $this->storeUserPaymentsData($shopping_user, $ret);
            }
            //other
            $pay = new PayoneController();
            $pay->init($shopping_user, $shopping_order);
            $amount = Yard::instance('shopping')->totalWithShipping(2, '.', '') * 100;
            $reference = $pay->setPrePayment(Request::get('payment_method'), $amount, 'EUR', $ret);
            $this->putPayments('payment_reference', $reference);
            $pay->setPersonalData();
            return $pay->ResponseData();
        }

        return redirect()->back();
    }


    public function transactionStatus($status, $reference){

        $shopping_order_id = $this->getPayments('shopping_order_id');

        $ShoppingPayment = ShoppingPayment::where('shopping_order_id', $shopping_order_id)->where('reference', $reference)->first();
        if(!$ShoppingPayment){
            //TODO log this
            Util::setUserHistoryValue(['status'=>21]);
            \Session::flash('checkout-error', 'Der Zahlungsvorgang konnte nicht abgeschlossen werden, die Zahlung wurde nicht gefunden: '.$reference);
            return redirect(route('checkout.checkout_card'));
        }
        $ShoppingPayment->status = $status;
        $ShoppingPayment->save();

        if($status === "success"){

                Yard::instance('shopping')->destroy();
                $this->destroy();

                $payt = $ShoppingPayment->payment_transactions->last();
                AboHelper::createNewAbo($ShoppingPayment);
                $data = [
                    'user_shop' => Util::getUserShop(),
                    'order_reference' => $reference,
                    'pay_trans' => $payt,
                ];
                return view('web.templates.checkout-final', $data);
        }
        if($status === "cancel"){
            Util::setUserHistoryValue(['status'=>22]);
            \Session::flash('checkout-error', 'Der Zahlungsvorgang wurde abgebrochen, die Bestellung konnte nicht ausgeführt werden.');
            return redirect(route('checkout.checkout_card'));

        }
        if($status === "error"){
            Util::setUserHistoryValue(['status'=>23]);
            \Session::flash('checkout-error', 'Der Zahlungsvorgang wurde abgebrochen, die Bestellung konnte nicht ausgeführt werden.');
            return redirect(route('checkout.checkout_card'));

        }
    }

    public function transactionApproved($transactionId, $reference)  {

        $payt = PaymentTransaction::findOrFail($transactionId);
        if($payt->shopping_payment->reference != $reference){
            abort(404);
        }

        Yard::instance('shopping')->destroy();
        $this->destroy();

        //Rechnung MIV
        if($payt->status === 'FNCMIV'){
            $this->directPaymentStatus($payt);
        }

        $data = [
            'user_shop' => Util::getUserShop(),
            'order_reference' => $payt->shopping_payment->reference,
            'pay_trans' => $payt,
        ];
        return view('web.templates.checkout-final', $data);
    }

    private function storeUserPaymentsData($shopping_user, $ret){
        if($shopping_user->auth_user_id){
            $user = User::find($shopping_user->auth_user_id);
            if($user && $user->account){
                if(isset($ret['elv']) && is_array($ret['elv'])){
                    $user->account->payment_data = $ret['elv'];
                    $user->account->save();
                }
            }
        }
    }

    private function makeShoppingUser($data){

        $data['same_as_billing'] = isset($data['same_as_billing']) ? false : true; //reinvert
        $data['accepted_data_checkbox'] = isset($data['accepted_data_checkbox']) ? true : false;
        $shopping_user = false;
        if($this->getPayments('shopping_user_id')){
            $shopping_user = ShoppingUser::find($this->getPayments('shopping_user_id'));
            if($shopping_user){
                $shopping_user->fill($data);
                $shopping_user->mode = null;
                $shopping_user->save();
            }
        }
        if(!$shopping_user){
            $shopping_user = ShoppingUser::create($data);
        }
        $this->putPayments('shopping_user_id', $shopping_user->id);

        return $shopping_user;
    }

    private function makeCustomerShoppingUser($shopping_data){
       // $shopping_user = ShoppingUser::findOrFail($shopping_data['shopping_user_id']);
        $shopping_user = new ShoppingUser();
        $shopping_user->fill($shopping_data);
        $shopping_user->faker_mail = false;

        $shopping_user->auth_user_id = null;
        $shopping_user->homeparty_id = null;
        $shopping_user->same_as_billing = $shopping_user->same_as_billing ? false : true; //reinvert
      // $shopping_user->id = null;
      $shopping_user->accepted_data_checkbox = 1;

        return $shopping_user;

    }
    private function makeShoppingOrder($shopping_user, $data){

        $user_shop = Util::getUserShop();

        if($shopping_user->is_from === 'homeparty'){
            //get data
            $homeparty = Homeparty::find($shopping_user->homeparty_id);
            //set Data!
            $total = Yard::instance('shopping')->total(2, '.', ''); //ek_price
            $data = [
                'shopping_user_id' => $shopping_user->id,
                'auth_user_id' => $shopping_user->auth_user_id,
                'country_id' => Yard::instance('shopping')->getShippingCountryId(),
                'language' => \App::getLocale(),
                'user_shop_id' => $user_shop->id,
                'payment_for' => $shopping_user->getOrderPaymentFor(),
                'homeparty_id' =>  $shopping_user->homeparty_id,
                'total' => $total,
                'subtotal' => $homeparty->order['ek_price_net'],
                'shipping' => $homeparty->order['shipping_price'],
                'shipping_net' => $homeparty->order['shipping_price_net'],
                'subtotal_ws' => 0,
                'tax' => $total - $homeparty->order['ek_price_net'],
                'total_shipping' => Yard::instance('shopping')->totalWithShipping(2, '.', ''),
                'points' => $homeparty->order['points'] - $homeparty->order['bonus_points_diff'],
                'weight' => 0,
                'txaction' => 'prev',
                'mode' => Util::getUserShoppingMode(),
            ];
        }elseif($shopping_user->is_from === 'collection'){
                //get data
                $ShoppingCollectOrder = ShoppingCollectOrder::find($shopping_user->shopping_collect_order_id);
                //set Data!
                $total = Yard::instance('shopping')->total(2, '.', ''); //ek_price
                $data = [
                    'shopping_user_id' => $shopping_user->id,
                    'auth_user_id' => $shopping_user->auth_user_id,
                    'country_id' => Yard::instance('shopping')->getShippingCountryId(),
                    'language' => \App::getLocale(),
                    'user_shop_id' => $user_shop->id,
                    'payment_for' => $shopping_user->getOrderPaymentFor(),
                    'total' => $total,
                    'subtotal' => $ShoppingCollectOrder->price_total_net,
                    'shipping' => 0,
                    'shipping_net' => 0,
                    'subtotal_ws' => $ShoppingCollectOrder->price_total_net,
                    'tax' => $ShoppingCollectOrder->tax_total,
                    'tax_split' =>  $ShoppingCollectOrder->tax_split, 
                    'total_shipping' => Yard::instance('shopping')->totalWithShipping(2, '.', ''),
                    'points' => $ShoppingCollectOrder->points,
                    'weight' => 0,
                    'txaction' => 'prev',
                    'mode' => Util::getUserShoppingMode(),
                ];
        }else{
            $data = [
                'shopping_user_id' => $shopping_user->id,
                'auth_user_id' => $shopping_user->auth_user_id,
                'country_id' => Yard::instance('shopping')->getShippingCountryId(),
                'language' => \App::getLocale(),
                'user_shop_id' => $user_shop->id,
                'payment_for' => $shopping_user->getOrderPaymentFor(),
                'total' => Yard::instance('shopping')->total(2, '.', ''),
                'subtotal' => Yard::instance('shopping')->subtotal(2, '.', ''),
                'shipping' => Yard::instance('shopping')->shipping(2, '.', ','),
                'shipping_net' => Yard::instance('shopping')->shippingNet(2, '.', ''),
                'subtotal_ws' => Yard::instance('shopping')->subtotalWithShipping(2, '.', ''),
                'tax' => Yard::instance('shopping')->taxWithShipping(2, '.', ''),
                'total_shipping' => Yard::instance('shopping')->totalWithShipping(2, '.', ''),
                'points' => Yard::instance('shopping')->points(),
                'weight' => Yard::instance('shopping')->weight(),
                'is_abo' => isset($data['is_abo']) ? $data['is_abo'] : false,
                'abo_interval' => isset($data['abo_interval']) ? $data['abo_interval'] : null,
                'txaction' => 'prev',
                'mode' => Util::getUserShoppingMode(),
            ];
        }

        $shopping_order= false;
        if($this->getPayments('shopping_order_id')){
            $shopping_order = ShoppingOrder::find($this->getPayments('shopping_order_id'));
            if($shopping_order){
                $shopping_order->fill($data);
                $shopping_order->save();
            }
        }
        if(!$shopping_order){
            $shopping_order = ShoppingOrder::create($data);
            if($shopping_user->is_from === 'collection' && $ShoppingCollectOrder){
                $ShoppingCollectOrder->shopping_order_id = $shopping_order->id;
                $ShoppingCollectOrder->save();
            }
        }
        $this->putPayments('shopping_order_id', $shopping_order->id);

         $items = Yard::instance('shopping')->getContentByOrder();
         $shopping_order->shopping_order_items()->each(function($model) use ($items, $shopping_order, $shopping_user) {
             foreach ($items as $item) {
                    if ($model->row_id === $item->rowId) {
                        $price_net = Yard::instance('shopping')->rowPriceNet($item, 2, '.', '');
                        $tax = $item->price - $price_net;
                        $data = [
                            'shopping_order_id' => $shopping_order->id,
                            'row_id' =>  $item->rowId,
                            'product_id' => $item->id,
                            'comp' => $item->options->comp,
                            'qty' => $item->qty,
                            'price' => $item->price,
                            'price_net' => $price_net,
                            'tax_rate' => $item->taxRate,
                            'tax' => $tax,
                            'price_vk_net' => $shopping_order->getPriceVkNetBy($item->id),
                            'discount' => $item->options->no_commission ? 0 : $shopping_order->getUserDiscount(),
                            'points' => $item->options->points,
                            'slug' => $item->options->slug,
                        ];
                        if($shopping_user->is_from === 'homeparty'){
                            $data['homeparty_id'] = (int) $shopping_user->homeparty_id;
                            $data['product_id'] = null;
                        }
                        if($shopping_user->is_from === 'collection'){
                            $data['shopping_collect_order_id'] = (int) $shopping_user->shopping_collect_order_id;
                            $data['product_id'] = null;
                        }
                        $model->fill($data)->save();
                        return false;
                    }
                }
                return $model->delete();
        });
        foreach ($items as $item) {
            if (!ShoppingOrderItem::where('shopping_order_id', $shopping_order->id)->where('row_id', $item->rowId)->count()){

                $price_net = Yard::instance('shopping')->rowPriceNet($item, 2, '.', '');
                $tax = $item->price - $price_net;

                $data = [
                    'shopping_order_id' => $shopping_order->id,
                    'row_id' =>  $item->rowId,
                    'product_id' => $item->id,
                    'comp' => $item->options->comp,
                    'qty' => $item->qty,
                    'price' => $item->price,
                    'price_net' => $price_net,
                    'tax_rate' => $item->taxRate,
                    'tax' => $tax,
                    'price_vk_net' => $shopping_order->getPriceVkNetBy($item->id),
                    'discount' => $item->options->no_commission ? 0 : $shopping_order->getUserDiscount(),
                    'points' => $item->options->points,
                    'slug' => $item->options->slug
                ];

                if($shopping_user->is_from === 'homeparty'){
                    $data['homeparty_id'] = (int) $shopping_user->homeparty_id;
                    $data['price_vk_net'] = 0;
                    $data['product_id'] = null;
                }
                if($shopping_user->is_from === 'collection'){
                    $data['price_vk_net'] = 0;
                    $data['shopping_collect_order_id'] = (int) $shopping_user->shopping_collect_order_id;
                    $data['product_id'] = null;
                }
                $shopping_order_item = ShoppingOrderItem::create($data);
            }
        }
        if($shopping_user->is_from === 'homeparty'){
            $shopping_order->makeHomepartyTaxSplit();
        }elseif($shopping_user->is_from === 'collection'){
            //is set on create / filll.
        }else{
            $shopping_order->makeTaxSplit();
        }
        return $shopping_order;
    }

    private function putPayments($key, $value){
        $content = $this->getContent();
        $content->put($key, $value);
        $this->session->put($this->instance, $content);

    }

    private function getPayments($key){
        $content = $this->getContent();
        if ($content->has($key)){
            return $content->get($key);
        }
        return false;
    }

    private function getContent()
    {
        if (is_null($this->session->get($this->instance))) {
            return new Collection([]);
        }
        return $this->session->get($this->instance);
    }

    public function destroy()
    {
        $this->session->remove($this->instance);
    }

    //is for Rechnung MIV
    private function directPaymentStatus(PaymentTransaction $payt){

        if(isset($payt->transmitted_data['param'])){
            $shopping_order = ShoppingOrder::find($payt->transmitted_data['param']);
            $shopping_order->txaction = 'invoice_open';
            $shopping_order->save();
            $shopping_payment = ShoppingPayment::where('reference', $payt->transmitted_data['reference'])->first();
            if($shopping_payment){
                $shopping_payment->txaction = 'invoice_open';
                $shopping_payment->save();
            }
            $send_link = Payment::paymentStatusPaidAction($shopping_order, false);
            $data = [
               'mode' => $payt->transmitted_data['mode'],
                'txaction' => $payt->txaction,
                'send_link' => $send_link,
            ];
            Payment::paymentStatusSendMail($shopping_order, $shopping_payment, $data);
        }

    }

}