<?php
namespace WooOrderCart\Front;
use WooOrderCart\Front\CartgateIntegrations\CartgateProductContextRenderer;
use WooOrderCart\Front\CartgateIntegrations\CartgateYithBoughtTogetherIntegration;
use WooOrderCart\Front\CartgateNotice\CartgateNoticeEmitter;
use WooOrderCart\Front\CartgateNotice\CartgateNoticePayload;
use WooOrderCart\Front\CartgateValidation\CartgateRuleEvaluator;
use WooOrderCart\Utilities\Cartgate\CG_BundleResolver;
use WooOrderCart\Utilities\Cartgate\CG_ManageData;
use WooOrderCart\Utilities\Cartgate\CartgateProductFacts;


class Cartgate{

protected static $_instance = null;

public $cartgateSettings;


  // Instance of Sidecart
  public static function instance() {
    if ( is_null( self::$_instance ) ) {
        self::$_instance = new self();
    }
    return self::$_instance;
}


public function __construct(){
    $this->cartgateSettings = wooordercart_ips_get_pluginsettings('cartgate_general_tabs');


    add_filter('woocommerce_mini_cart_item_class', array( $this,'ips_additional_cartdata'), 10, 3);

    
    add_action('woocommerce_after_add_to_cart_button', array( $this,'ips_add_categories'), 10, 3);      // Single Product Page
    
   
    add_action('woocommerce_after_shop_loop_item', array( $this,'ips_add_categories'), 10, 3);         // Shop Page


    add_action('woocommerce_after_shop_loop_item_title',  array( $this,'ips_add_categories'), 15);     // Start page

  
}

private function get_message_renderer_mode(): string {
    return 'ips_react';
}

private function uses_ips_react_message_renderer(): bool {
    return true;
}


public function ips_custom_redirect_after_login($redirect_to, $user) {
    add_filter('woocommerce_persistent_cart_enabled', '__return_false');


    // Hier kannst du eine benutzerdefinierte Weiterleitung hinzufügen
    // Beispiel: Benutzer nach dem Login auf die Startseite umleiten
    return $redirect_to;
}


public function check_session_carts() {


}


public function ips_cartgate_settings($filename) {


}

public function ips_custom_boughttogether_info($product) {
    CartgateYithBoughtTogetherIntegration::render_bought_together_context( $product );
   }


   public function ips_check_disable_order_bumps($display_bump, $order_bump_instance, $location) {
        unset( $order_bump_instance, $location );

        $result_proof = $display_bump;
        $woocommerce = function_exists( 'WC' ) ? WC() : null;
        if ( true !== $display_bump || ! isset( $woocommerce->cart )
            || ! is_callable( [ $woocommerce->cart, 'get_cart_contents_count' ] )
            || $woocommerce->cart->get_cart_contents_count() <= 0 ) {
            return $result_proof;
        }

        $cart_pass = true;
        $product = null;
        $all_cartgate_results = [];
        $and_cart_results = [];
        $cartgate_boxes = function_exists( 'wooordercart_ips_gettable_cartgateoptions_key' )
            ? wooordercart_ips_gettable_cartgateoptions_key()
            : [];

        foreach ( (array) $cartgate_boxes as $cartgate_box ) {
            if ( empty( $cartgate_box['ips-mb-cartgate-addon-noorderbump'] ) ) {
                continue;
            }

            $or_cart_rules = CG_ManageData::instance()->get_orlabel_from_cartgatebox_cart( $cartgate_box );
            foreach ( $or_cart_rules as $or_rule ) {
                $and_cart_results[] = CG_ManageData::instance()->check_allmust_true(
                    CG_ManageData::instance()->check_and_array( $or_rule, $product, 'cartcheck' )
                );
            }

            $cart_pass = CG_ManageData::instance()->check_min_one_true( $and_cart_results );
            $all_cartgate_results[] = $cart_pass;

            $result_proof = CG_ManageData::instance()->check_min_one_true( $all_cartgate_results )
                ? false
                : true;
        }

        return $result_proof;
}


public function ips_cartgate_addtocart_validation( $passed, $product_id, $quantity, $variation_id = 0, $variations = array(), $cart_item_data = array() ) {
   if ( ! $passed ) {
       return $passed;
   }

   CartgateNoticePayload::clear_pending();

   $decision = CartgateRuleEvaluator::instance()->evaluate_add_to_cart(
       $product_id,
       $quantity,
       $variation_id,
       is_array( $cart_item_data ) ? $cart_item_data : array()
   );

   if ( $decision->is_allowed() ) {
       return $passed;
   }

   CartgateNoticeEmitter::emit_decision( $decision );

   return false;


}

private function resolve_cartgate_notice_message( array $cartgatebox ): string {
    $show_notice = $cartgatebox['ips-mb-cartgate-showmessage'] ?? false;

    if ( ! filter_var( $show_notice, FILTER_VALIDATE_BOOLEAN ) && '1' !== (string) $show_notice ) {
        return __( 'This product combination is not available.', 'ips-order-cart' );
    }

    $lead = trim( (string) ( $cartgatebox['ips-mb-cartgate-addon-leadtext'] ?? '' ) );
    $text = trim( (string) ( $cartgatebox['ips-mb-cartgate-addon-noticetext'] ?? '' ) );

    if ( '' === $lead && '' === $text ) {
        return __( 'This product combination is not available.', 'ips-order-cart' );
    }

    if ( '' === $lead ) {
        return $text;
    }

    if ( '' === $text ) {
        return $lead;
    }

    return sprintf( '%s %s', $lead, $text );
}

/**
 * @param array<string,mixed> $cartgatebox
 * @param array<string,mixed>|null $payload
 */
private function should_emit_native_woo_notice( array $cartgatebox, ?array $payload ): bool {
    if ( rest_sanitize_boolean( $cartgatebox['ips-mb-cartgate-addon-nativenotice'] ?? false ) ) {
        return true;
    }

    if ( ! $this->uses_ips_react_message_renderer() && $this->should_emit_ips_notice( $cartgatebox ) ) {
        return true;
    }

    return false;
}

/**
 * @param array<string,mixed> $cartgatebox
 */
private function should_emit_ips_notice( array $cartgatebox ): bool {
    $show_notice = $cartgatebox['ips-mb-cartgate-showmessage'] ?? false;

    return filter_var( $show_notice, FILTER_VALIDATE_BOOLEAN ) || '1' === (string) $show_notice;
}

/**
 * @param array<string,mixed> $cartgatebox
 */
private function add_cartgate_notice( string $message, array $cartgatebox = array() ): void {
    $message = trim( wp_strip_all_tags( $message ) );

    if ( '' === $message ) {
        $message = __( 'This product combination is not available.', 'ips-order-cart' );
    }

    $payload = CartgateNoticePayload::build_from_cartgatebox( $cartgatebox );
    if ( is_array( $payload ) ) {
        CartgateNoticePayload::store_pending( $payload );
    } else {
        CartgateNoticePayload::clear_pending();
    }

    if ( ! $this->should_emit_native_woo_notice( $cartgatebox, $payload ) ) {
        return;
    }

    $existing_notices = wc_get_notices( 'error' );

    foreach ( $existing_notices as $notice ) {
        $existing_message = is_array( $notice ) ? (string) ( $notice['notice'] ?? '' ) : (string) $notice;
        if ( trim( wp_strip_all_tags( $existing_message ) ) === $message ) {
            return;
        }
    }

    wc_add_notice( $message, 'error' );
}


public function ips_cartgate_addtocart_validation_old( $passed, $product_id, $quantity ) {
   
 
    // U ∧ V ∧ W     ∨     L ∧ M ∧ N     ∨     X ∧ Y ∧ Z


    $result_proof = true;
    if ( WC()->cart->get_cart_contents_count() != 0 ) {

    $product = wc_get_product( $product_id );
    
    $product_pass = true;
	$cart_pass = true;
    
    $cartgateboxall = array();
    //$cartgateboxall = wooordercart_ips_getposttyp_cartgateoptions();
    //$cartgateboxall = wooordercart_ips_gettable_cartgateoptions();
    $cartgateboxall = wooordercart_ips_gettable_cartgateoptions_key();


    $ALLCARTGATERESULT = [];


    $ANDARRAY_PRODUCT = []; 
    $ANDARRAY_CART = []; 


    foreach ($cartgateboxall as $cartgatebox) {

        
        $controldirection = $cartgatebox[1]['ipscmi-order-cart-cartgate-settings-direction'];


        $ORLABEL_PRODUCT = CG_ManageData::instance()->get_orlabel_from_cartgatebox_product($cartgatebox);
      
        $ORLABEL_CART = CG_ManageData::instance()->get_orlabel_from_cartgatebox_cart($cartgatebox);
     
       
        foreach ($ORLABEL_PRODUCT as $OR) {

            // X ∨ Y ∨ Z
            $ANDARRAY_PRODUCT[] = CG_ManageData::instance()->check_allmust_true(CG_ManageData::instance()->check_and_array($OR, $product, 'productcheck')); 
    
        }

        foreach ($ORLABEL_CART as $OR) {

            // X ∨ Y ∨ Z
            $ANDARRAY_CART[] = CG_ManageData::instance()->check_allmust_true(CG_ManageData::instance()->check_and_array($OR, $product, 'cartcheck')); 
    
        }

        if (CG_ManageData::instance()->check_min_one_true($ANDARRAY_PRODUCT)) {

          
            $product_pass = true;

        }else{
            $product_pass = false;
        }

        if (CG_ManageData::instance()->check_min_one_true($ANDARRAY_CART)) {

          
            $cart_pass = true;

        }else{
            $cart_pass = false;
        }
    
        
        $ANDARRAY_PRODUCT = [];
        $ANDARRAY_CART = [];

        if($controldirection === 'whitelist'){
        $result_pass = ($product_pass === $cart_pass);
        }else{
        $result_pass = ($product_pass xor $cart_pass);
        }
        $ALLCARTGATERESULT[] = $result_pass;

        if (CG_ManageData::instance()->check_allmust_true(($ALLCARTGATERESULT))) {
            $result_proof = true;
        }else{
            $result_proof = false;
        }
        

    }


    if(!$result_proof){
 
        // Optional: Verhindere einen Weiterleitungs- oder Seitenladevorgang
        return $result_proof;
       //   wp_die();
      }

    }

   
    return $result_proof;


}


public function get_producttyp_from_product($product){
    $addto_producttyp = "unknown";
if($product->is_type('simple')){

    if ($product->is_downloadable()) {
        $addto_producttyp = 'downloadable';
    } else {
        $addto_producttyp = 'simple';
    }

}else{
    $addto_producttyp = $product->get_type();

}

return $addto_producttyp;

}


public function check_productlist($product_id, $array ){

	$back = false;
	
	    // NOT empty
       if ( !empty( $array ) ) {
		  
            // If new added quantity greater than max quantity
             $count = count($array);
		 
			for($i=0; $i<$count; $i++) {
				
				$back = ($array[$i] == $product_id ? true : false); // returns true
				 if ($back == true) {
					 
    				break;
  					}
				
			}
		}
	return $back;
	
	
}


public function check_productlist_to_cat($addto_productcategories, $validationcat) {
    if (empty($addto_productcategories) || empty($validationcat) || !is_array($addto_productcategories) || !is_array($validationcat)) {
        return false;
    }

    foreach ($validationcat as $element) {
        if (!in_array($element, $addto_productcategories)) {
            return false;
        }
    }

    return true;
}


public function check_productlist_to_cat_any($addto_productcategories, $validationcat) {
    $checkresult = false;
    if (empty($addto_productcategories) || empty($validationcat) || !is_array($addto_productcategories) || !is_array($validationcat)) {
        return $checkresult;
    }

    foreach ($validationcat as $element) {
        if (in_array($element, $addto_productcategories)) {
            $checkresult = true;
        }
    }

    return $checkresult;
}


public function check_productlist_to_cat_old($addto_productcategories, $validationcat) {
    if (empty($addto_productcategories) || empty($validationcat)) {
        return false;
    }

    $intersection = array_intersect($addto_productcategories, $validationcat);
    return !empty($intersection);
}


public function is_category_in_cart($category_slug) {
    // Überprüfe, ob der Warenkorb nicht leer ist
    if (WC()->cart->get_cart_contents_count() != 0) {
        // Durchlaufe die Produkte im Warenkorb
        foreach (WC()->cart->get_cart() as $cart_item) {
            $product_id = $cart_item['product_id'];
            $product_categories = get_the_terms($product_id, 'product_cat'); // Hole die Kategorien des Produkts

            // Überprüfe, ob das Produkt Kategorien hat
            if (!empty($product_categories) && !is_wp_error($product_categories)) {
                foreach ($product_categories as $category) {
                    // Überprüfe, ob die Kategorie des Produkts mit der gesuchten Kategorie übereinstimmt
                    if ($category->slug === $category_slug) {
                        return true; // Die Kategorie wurde im Warenkorb gefunden
                    }
                }
            }
        }
    }
    return false; // Die Kategorie wurde nicht im Warenkorb gefunden
}


public function is_anycategory_in_cart($category_ids) {
    // Überprüfe, ob der Warenkorb nicht leer ist
    if (WC()->cart->get_cart_contents_count() != 0) {
        // Durchlaufe die Produkte im Warenkorb
        foreach (WC()->cart->get_cart() as $cart_item) {
            $product_id = $cart_item['product_id'];
           // $product_categories = get_the_terms($product_id, 'product_cat'); // Hole die Kategorien des Produkts als NAME
           $product_categories = wp_get_post_terms($product_id, 'product_cat', array('fields' => 'ids'));

            // Überprüfe, ob das Produkt Kategorien hat
            if (!empty($product_categories) && !is_wp_error($product_categories)) {
                foreach ($product_categories as $category_id) {
                    // Überprüfe, ob die Kategorie des Produkts in der Liste von Kategorien ist
          
                    if (in_array($category_id, $category_ids)) {
                        return true; // Eine der Kategorien wurde im Warenkorb gefunden
                    }
                }
            }
        }
    }
    return false; // Keine der Kategorien wurde im Warenkorb gefunden
}


public function is_anyproducttyp_in_cart($validation_ptyp) {
    // Überprüfe, ob der Warenkorb nicht leer ist

    if (WC()->cart->get_cart_contents_count() != 0) {
        // Durchlaufe die Produkte im Warenkorb
        foreach (WC()->cart->get_cart() as $cart_item) {
            $product = $cart_item['data'];
            //$thisproducttyp = $product->get_type();
            $thisproducttyp = $this->get_producttyp_from_product($product);

            //$product_id = $cart_item['product_id'];
           // $product_categories = get_the_terms($product_id, 'product_cat'); // Hole die Kategorien des Produkts als NAME
          

            // Überprüfe, ob das Produkt Kategorien hat
            if (!empty($thisproducttyp) && !is_wp_error($thisproducttyp)) {
               
                    // Überprüfe, ob die Kategorie des Produkts in der Liste von Kategorien ist
   
                    $validation_ptyp_flat = array_merge(...$validation_ptyp);
                    if (in_array($thisproducttyp, $validation_ptyp_flat)) {

                        return true; // Eine der Kategorien wurde im Warenkorb gefunden
                    }
                
            }
        }
    }
    return false; // Keine der Kategorien wurde im Warenkorb gefunden
}


public function is_anycategory_in_cartonly($category_ids) {
    // Überprüfe, ob der Warenkorb nicht leer ist
    $checkresult = false;
    if (is_array($category_ids)) {
    if (WC()->cart->get_cart_contents_count() != 0) {
        $found_categories = array();

        // Durchlaufe die Produkte im Warenkorb
        foreach (WC()->cart->get_cart() as $cart_item) {
            $product_id = $cart_item['product_id'];
            $product_categories = wp_get_post_terms($product_id, 'product_cat', array('fields' => 'ids'));
            // Füge die Kategorien des aktuellen Produkts zu den gefundenen Kategorien hinzu
            $found_categories = array_merge($found_categories, $product_categories);
        }

        // Überprüfe, ob alle Kategorien in $category_ids enthalten sind
        // und ob es keine zusätzlichen Kategorien gibt, die nicht in $category_ids enthalten sind
        $checkresult = $this->contains_only_categories($found_categories, $category_ids);
    }
    }
    return $checkresult;
}


public function is_anycategory_in_cartonly_old($category_ids) {
    // Überprüfe, ob der Warenkorb nicht leer ist
    $checkresult = false;
    if (WC()->cart->get_cart_contents_count() != 0) {
        $found_categories = array();

        // Durchlaufe die Produkte im Warenkorb
        foreach (WC()->cart->get_cart() as $cart_item) {
            $product_id = $cart_item['product_id'];
            $product_categories = wp_get_post_terms($product_id, 'product_cat', array('fields' => 'ids'));

            $found_categories = array_merge($found_categories, $product_categories);

    }


$checkresult = $this->contains_only_categories($found_categories, $category_ids);
}

    return $checkresult; // Keine der Kategorien wurde im Warenkorb gefunden
}


public function ips_additional_cartdata($cart_data, $cart_item) {

    
    $cart_data2[] = array(
        'value' => '<strong>100</strong>',
    );

    return $cart_data2;


}

public function contains_only_categories($found_categories, $category_ids) {
    // Überprüfe, ob die Anzahl der Kategorien im Warenkorb gleich der Anzahl der Kategorien in $category_ids ist
    if (count($found_categories) !== count($category_ids)) {
        return false;
    }

    // Überprüfe, ob alle Kategorien im Warenkorb in $category_ids enthalten sind
    foreach ($found_categories as $category) {
        if (!in_array($category, $category_ids)) {
            return false;
        }
    }

    return true;
}

public function contains_only_categories_old($haystack, $categories_to_check) {


    if (!is_array($haystack) || !is_array($categories_to_check)) {
        // Fehlerbehandlung, wenn eine der Variablen kein Array ist
  
        return false;
    }


    // Finde die Differenz zwischen den beiden Arrays
    $difference = array_diff($haystack, $categories_to_check);

    // Wenn die Differenz leer ist, bedeutet das, dass alle Kategorien in $categories_to_check vorhanden sind
    return empty($difference);
}


public function ips_additional_cartdata2($cart_item_html, $cart_item, $cart_item_key) {

    $category_string = ''; 

    $custom_data_html = '<input type="hidden" class="ips_wooadd_cat" data-cat="' . esc_attr($category_string) . '"  name="ips_woo_cat">';


    $cart_item_html .= $custom_data_html;

    return $cart_item_html;

}


public function ips_additional_cartdata3($classes, $cart_item, $cart_item_key) {
  //  $classes = 'ips-mini-cart-item';
  
  $cat_ids = array();
  $cart_amount = 0;


  if (function_exists('WC')) {
    $cart_items = null;
    $cart_amount = WC()->cart->get_cart_contents_count();
  }


  $product_id = $cart_item['product_id'];
  $product = wc_get_product($product_id);

  
if ($product instanceof WC_Product && $product->is_type('simple')) {

   $catproductid = $product->get_id();
   $cat_ids = $product->get_category_ids();

   
}else if ($product instanceof WC_Product_Bundle) {

  $catproductid = $product->get_id();
  $cat_ids = $product->get_category_ids();
  
  
}else{
 
    $catproductid = $product->get_data()['parent_id'];
    $cat_ids = $product->get_data()['category_ids'];
   
}


     $category_string = implode(',', $cat_ids);
     

  $classes .= ' ipscmi-order-cart-cats';
    

  $data_cat_value = $category_string;


  $data_cat_html = ' ipsdata-cartamount=(' . esc_attr($cart_amount) . ') ipsdata-cat=(' . esc_attr($data_cat_value) . ')';
  $classes .= $data_cat_html;

  return $classes;

}


public function ips_additional_cartgate_info($raw_item, $item_key, $item) {
    unset( $raw_item, $item_key );
    if ( is_object( $item ) && method_exists( $item, 'get_product' ) ) {
        CartgateProductContextRenderer::render_hidden_input(
            $item->get_product(), 'ips_wooadd_cat', 'data-cat', 'ips_woo_cat', true, true
        );
    }

}


    public function ips_add_categories() {
        global $product;
        $product_category_ids = array();
    

        if ($product) {

              // Verhindere doppelten Output pro Produkt
    static $displayed_products = array();
    $product_id = $product->get_id();
    
    if ( in_array( $product_id, $displayed_products ) ) {
        return; // Bereits ausgegeben
    }


            if ($product->is_type('variation')) {
                $parent_id = $product->get_parent_id();
                $parent_product = wc_get_product($parent_id);
            
                if ($parent_product) {
                    $parent_category_ids = wp_get_post_terms($parent_product->get_id(), 'product_cat', array('fields' => 'ids'));
                   // $categorieids_string = implode(', ', $parent_category_ids);
                    $product_category_ids = $parent_category_ids;
                }
            } else{
                $product_category_ids = wp_get_post_terms($product->get_id(), 'product_cat', array('fields' => 'ids'));
            }


            $categorieids_string = implode(', ', $product_category_ids);

            $producttyp = $this->get_current_producttyp($product);
            $stock_status = method_exists( $product, 'get_stock_status' ) ? $product->get_stock_status() : 'instock';
            $product_facts = CartgateProductFacts::build( $product );
            $manual_check = $product_facts['manualCheck'] ? 'yes' : 'no';
            $attribute_flags = implode( ', ', $product_facts['attributeFlags'] );

                // Download-Flag und Virtuell-Flag
            $downloadable = $product->is_downloadable() ? 'yes' : 'no';
            $virtual      = $product->is_virtual()      ? 'yes' : 'no';


            // Ausgabe des HTML-Eingabefelds
            //echo '<input type="hidden" class="ips_wooadd_cartcats" data-catids="' . esc_attr($categorieids_string) . '"  data-ptyp="' . esc_attr($producttyp) . '" name="ips_woo_cat">';
            echo '<input type="hidden" 
            class="ips_wooadd_cartcats" 
            data-product-id="' . esc_attr( (string) $product->get_id() ) . '"
            data-catids="' . esc_attr($categorieids_string) . '"  
            data-ptyp="' . esc_attr($producttyp) . '"
            data-stock-status="' . esc_attr( $stock_status ) . '"
            data-manual-check="' . esc_attr( $manual_check ) . '"
            data-attribute-flags="' . esc_attr( $attribute_flags ) . '"
            data-downloadable="' . esc_attr($downloadable) . '"
            data-virtual="' . esc_attr($virtual) . '"
            name="ips_woo_cat">';
       
       
        }
    }


    public function get_current_producttyp($product) {
        if (!$product) {
            return 'unknown';
        }
    
        return $product->get_type(); 
        // Liefert immer: 'simple', 'variation', 'variable', 'subscription', 'bundle', 'external', 'grouped' ...
    }


    public function get_current_producttyp_old2($product) {
        $product_type = 'unknown';
    
        if (!$product) {
            return $product_type; // Oder 'unknown', falls kein Produkt
        }
    
        // 1) Konkrete Variation (Kunde hat schon eine Variation ausgewählt)
        if ($product->is_type('variation')) {
            // Prüfen, ob Variation downloadbar oder virtuell ist
            if ($product->is_downloadable()) {
                $product_type = 'downloadable';
            } elseif ($product->is_virtual()) {
                $product_type = 'virtual';
            } else {
                // Variation ohne Flags
                $product_type = 'variable';
            }
        }
        // 2) Einfaches Produkt
        elseif ($product->is_type('simple')) {
            if ($product->is_downloadable()) {
                $product_type = 'downloadable';
            } elseif ($product->is_virtual()) {
                $product_type = 'virtual';
            } else {
                $product_type = 'simple';
            }
        }
        // 3) Variables Produkt (wenn noch keine Variation gewählt)  
        elseif ($product->is_type('variable')) {
            // Optional: Durchlaufe alle Kinder und prüfe, ob mindestens eine Variation downloadable oder virtual ist
            $downloadable = false;
            $virtual      = false;
            $children = $product->get_children();
            foreach ($children as $child_id) {
                $child = wc_get_product($child_id);
                if ($child) {
                    if ($child->is_downloadable()) {
                        $downloadable = true;
                        break; // Downloadbar hat ggf. Priorität
                    }
                    if ($child->is_virtual()) {
                        $virtual = true;
                    }
                }
            }
            if ($downloadable) {
                $product_type = 'downloadable';
            } elseif ($virtual) {
                $product_type = 'virtual';
            } else {
                $product_type = 'variable';
            }
        }
        // 4) Andere WooCommerce-Typen
        elseif ($product->is_type('bundle')) {
            $product_type = 'bundle';
        } elseif ($product->is_type('subscription')) {
            $product_type = 'subscription';
        } elseif ($product->is_type('external')) {
            $product_type = 'external';
        } elseif ($product->is_type('ticket-event')) {
            $product_type = 'ticket-event';
        } elseif ($product->is_type('grouped')) {
            $product_type = 'grouped';
        } else {
            $product_type = 'unknown';
        }
    
        return $product_type;
    }


    public function get_current_producttyp_old($product) {

        $product_type = null;
        
        // Typen:
        // WC_Product_Bundle
        // WC_Product_Simple
        // WC_Product_Variable
        // WC_Product_Subscription
        // WC_Product_External
        // WC_Product_Ticket_Event

        //$product = $cart_item['data'];
        //$product = $item->get_product();
        if ($product) {
            if($product->is_type('simple')){

                if ($product->is_downloadable()) {
                    $product_type = 'downloadable';
                } else {
                    $product_type = 'simple';
                }

            }elseif ($product->is_type('bundle')) {
                $product_type = 'bundle';
            }elseif ($product->is_type('subscription')) {
                $product_type = 'subscription';
            }elseif ($product->is_type('variable')) {
                $product_type = 'variable';
            }elseif ($product->is_type('external')) {
                $product_type = 'external';
            }elseif ($product->is_type('ticket-event')) {
                $product_type = 'ticket-event';
            }else{
                $product_type = 'unknown';
            }
        }


        return $product_type;
    }

    public function ips_add_categories_old(){
      //  $product = $item->get_product();

        global $product;

        $product_categorieids = wp_get_post_terms($product->get_id(), 'product_cat', array('fields' => 'ids'));
 
            $categorieids_string = implode(', ', $product_categorieids);

        if ($product) {
            $product_id = $product->get_id();
            // Verwende $product_id für weitere Verarbeitung
            echo '<input type="hidden" class="ips_wooadd_cartcats" data-catids="' . esc_attr($categorieids_string) . '"  name="ips_woo_cat">';
        }


    }
    public function ips_add_categories_test(){
        //  $product = $item->get_product();
  
  
              echo '<div>TEST TEXT</div>';
          
  
      }


}