// wp-config.php에 추가
define('WP_DEBUG', true);
define('WP_DEBUG_LOG', true);
define('WP_DEBUG_DISPLAY', false);
define('SCRIPT_DEBUG', true);

wc-custom-fields/
├── wc-custom-fields.php (메인 파일)
├── includes/
│   ├── class-product-fields.php
│   └── class-admin-settings.php
├── assets/
│   ├── css/
│   └── js/
└── languages/

<?php
/**
 * Plugin Name: WooCommerce Custom Product Fields
 * Plugin URI: https://www.jaenung.net
 * Description: 제품에 커스텀 필드를 추가하는 플러그인
 * Version: 1.0.0
 * Author: Your Name
 * Author URI: https://www.jaenung.net
 * Text Domain: wc-custom-fields
 * Domain Path: /languages
 * Requires at least: 5.8
 * Requires PHP: 7.4
 * WC requires at least: 5.0
 * WC tested up to: 8.0
 */

// 직접 접근 차단
if (!defined('ABSPATH')) {
    exit;
}

// WooCommerce 활성화 체크
if (!in_array('woocommerce/woocommerce.php', 
    apply_filters('active_plugins', get_option('active_plugins')))) {
    return;
}

// 플러그인 상수 정의
define('WC_CUSTOM_FIELDS_VERSION', '1.0.0');
define('WC_CUSTOM_FIELDS_PATH', plugin_dir_path(__FILE__));
define('WC_CUSTOM_FIELDS_URL', plugin_dir_url(__FILE__));

// 메인 클래스
class WC_Custom_Fields {
    
    private static $instance = null;
    
    public static function get_instance() {
        if (null === self::$instance) {
            self::$instance = new self();
        }
        return self::$instance;
    }
    
    private function __construct() {
        $this->init_hooks();
        $this->load_dependencies();
    }
    
    private function init_hooks() {
        add_action('plugins_loaded', array($this, 'load_textdomain'));
    }
    
    private function load_dependencies() {
        require_once WC_CUSTOM_FIELDS_PATH . 'includes/class-product-fields.php';
    }
    
    public function load_textdomain() {
        load_plugin_textdomain(
            'wc-custom-fields',
            false,
            dirname(plugin_basename(__FILE__)) . '/languages'
        );
    }
}

// 플러그인 초기화
function wc_custom_fields_init() {
    return WC_Custom_Fields::get_instance();
}

add_action('plugins_loaded', 'wc_custom_fields_init');

<?php
class WC_Product_Custom_Fields {
    
    public function __construct() {
        // 관리자 제품 편집 페이지에 필드 추가
        add_action('woocommerce_product_options_general_product_data', 
            array($this, 'add_custom_fields'));
        
        // 필드 저장
        add_action('woocommerce_process_product_meta', 
            array($this, 'save_custom_fields'));
        
        // 프론트엔드에 표시
        add_action('woocommerce_single_product_summary', 
            array($this, 'display_custom_fields'), 25);
    }
    
    public function add_custom_fields() {
        global $post;
        
        echo '<div class="options_group">';
        
        // 텍스트 필드
        woocommerce_wp_text_input(array(
            'id' => '_custom_text_field',
            'label' => __('커스텀 텍스트', 'wc-custom-fields'),
            'placeholder' => '특별한 정보를 입력하세요',
            'desc_tip' => true,
            'description' => __('제품 상세페이지에 표시될 추가 정보', 'wc-custom-fields'),
            'type' => 'text'
        ));
        
        // 숫자 필드
        woocommerce_wp_text_input(array(
            'id' => '_custom_number_field',
            'label' => __('배송 소요일', 'wc-custom-fields'),
            'placeholder' => '3',
            'desc_tip' => true,
            'description' => __('예상 배송 소요 일수', 'wc-custom-fields'),
            'type' => 'number',
            'custom_attributes' => array(
                'step' => '1',
                'min' => '1'
            )
        ));
        
        // 셀렉트 박스
        woocommerce_wp_select(array(
            'id' => '_custom_select_field',
            'label' => __('제품 등급', 'wc-custom-fields'),
            'options' => array(
                '' => __('선택하세요', 'wc-custom-fields'),
                'premium' => __('프리미엄', 'wc-custom-fields'),
                'standard' => __('스탠다드', 'wc-custom-fields'),
                'basic' => __('베이직', 'wc-custom-fields')
            )
        ));
        
        // 체크박스
        woocommerce_wp_checkbox(array(
            'id' => '_custom_checkbox_field',
            'label' => __('특별 배송', 'wc-custom-fields'),
            'description' => __('특별 배송 서비스 제공', 'wc-custom-fields')
        ));
        
        echo '</div>';
    }
    
    public function save_custom_fields($post_id) {
        // 텍스트 필드 저장
        $custom_text = isset($_POST['_custom_text_field']) 
            ? sanitize_text_field($_POST['_custom_text_field']) 
            : '';
        update_post_meta($post_id, '_custom_text_field', $custom_text);
        
        // 숫자 필드 저장
        $custom_number = isset($_POST['_custom_number_field']) 
            ? absint($_POST['_custom_number_field']) 
            : '';
        update_post_meta($post_id, '_custom_number_field', $custom_number);
        
        // 셀렉트 박스 저장
        $custom_select = isset($_POST['_custom_select_field']) 
            ? sanitize_text_field($_POST['_custom_select_field']) 
            : '';
        update_post_meta($post_id, '_custom_select_field', $custom_select);
        
        // 체크박스 저장
        $custom_checkbox = isset($_POST['_custom_checkbox_field']) 
            ? 'yes' 
            : 'no';
        update_post_meta($post_id, '_custom_checkbox_field', $custom_checkbox);
    }
    
    public function display_custom_fields() {
        global $product;
        
        $custom_text = get_post_meta($product->get_id(), '_custom_text_field', true);
        $custom_number = get_post_meta($product->get_id(), '_custom_number_field', true);
        $custom_select = get_post_meta($product->get_id(), '_custom_select_field', true);
        $custom_checkbox = get_post_meta($product->get_id(), '_custom_checkbox_field', true);
        
        if ($custom_text || $custom_number || $custom_select || $custom_checkbox === 'yes') {
            echo '<div class="custom-product-fields">';
            
            if ($custom_text) {
                echo '<p class="custom-field-text">';
                echo '<strong>' . __('추가 정보:', 'wc-custom-fields') . '</strong> ';
                echo esc_html($custom_text);
                echo '</p>';
            }
            
            if ($custom_number) {
                echo '<p class="custom-field-delivery">';
                echo '<strong>' . __('배송 소요:', 'wc-custom-fields') . '</strong> ';
                echo sprintf(__('%d일', 'wc-custom-fields'), $custom_number);
                echo '</p>';
            }
            
            if ($custom_select) {
                $grades = array(
                    'premium' => __('프리미엄', 'wc-custom-fields'),
                    'standard' => __('스탠다드', 'wc-custom-fields'),
                    'basic' => __('베이직', 'wc-custom-fields')
                );
                
                echo '<p class="custom-field-grade">';
                echo '<strong>' . __('제품 등급:', 'wc-custom-fields') . '</strong> ';
                echo esc_html($grades[$custom_select]);
                echo '</p>';
            }
            
            if ($custom_checkbox === 'yes') {
                echo '<p class="custom-field-special">';
                echo '⭐ ' . __('특별 배송 서비스 제공', 'wc-custom-fields');
                echo '</p>';
            }
            
            echo '</div>';
        }
    }
}

new WC_Product_Custom_Fields();

.custom-product-fields {
    background: linear-gradient(135deg, #f8f9fa 0%, #e9ecef 100%);
    padding: 20px;
    border-radius: 12px;
    margin: 20px 0;
    border-left: 4px solid #a29bfe;
}

.custom-product-fields p {
    margin: 10px 0;
    font-size: 15px;
    line-height: 1.6;
}

.custom-product-fields strong {
    color: #6c5ce7;
    font-weight: 600;
}

.custom-field-special {
    background: #ffeaa7;
    padding: 10px 15px;
    border-radius: 8px;
    display: inline-block;
}

public function __construct() {
    // 기존 코드...
    add_action('wp_enqueue_scripts', array($this, 'enqueue_styles'));
}

public function enqueue_styles() {
    if (is_product()) {
        wp_enqueue_style(
            'wc-custom-fields-frontend',
            WC_CUSTOM_FIELDS_URL . 'assets/css/frontend.css',
            array(),
            WC_CUSTOM_FIELDS_VERSION
        );
    }
}

class WC_Cart_Customizer {
    
    public function __construct() {
        // 장바구니 상단에 메시지 추가
        add_action('woocommerce_before_cart', array($this, 'add_cart_notice'));
        
        // 무료배송 진행률 표시
        add_action('woocommerce_before_cart_table', array($this, 'free_shipping_progress'));
        
        // 장바구니 비우기 버튼 커스터마이징
        add_filter('woocommerce_return_to_shop_text', array($this, 'custom_return_text'));
    }
    
    public function add_cart_notice() {
        if (WC()->cart->get_cart_contents_count() > 0) {
            echo '<div class="woocommerce-info custom-cart-notice">';
            echo '🎉 ' . __('장바구니에 상품이 담겼습니다! 지금 결제하시면 오늘 출고됩니다.', 'wc-custom-fields');
            echo '</div>';
        }
    }
    
    public function free_shipping_progress() {
        $free_shipping_threshold = 50000; // 무료배송 기준 금액
        $current_total = WC()->cart->get_subtotal();
        
        if ($current_total < $free_shipping_threshold) {
            $remaining = $free_shipping_threshold - $current_total;
            $progress_percent = ($current_total / $free_shipping_threshold) * 100;
            
            echo '<div class="free-shipping-progress">';
            echo '<div class="progress-bar-container">';
            echo '<div class="progress-bar" style="width: ' . $progress_percent . '%"></div>';
            echo '</div>';
            echo '<p class="progress-text">';
            echo sprintf(
                __('무료배송까지 <strong>%s</strong> 남았습니다! 🚚', 'wc-custom-fields'),
                wc_price($remaining)
            );
            echo '</p>';
            echo '</div>';
        } else {
            echo '<div class="free-shipping-achieved">';
            echo '✅ ' . __('무료배송 대상입니다!', 'wc-custom-fields');
            echo '</div>';
        }
    }
    
    public function custom_return_text($text) {
        return __('← 쇼핑 계속하기', 'wc-custom-fields');
    }
}

new WC_Cart_Customizer();

class WC_Gateway_Custom_Bank extends WC_Payment_Gateway {
    
    public function __construct() {
        // 게이트웨이 ID (고유값)
        $this->id = 'custom_bank_transfer';
        
        // 결제 방법 아이콘
        $this->icon = apply_filters('woocommerce_custom_bank_icon', '');
        
        // 직접 결제 여부
        $this->has_fields = true;
        
        // 관리자 페이지 제목
        $this->method_title = __('커스텀 무통장입금', 'wc-custom-fields');
        
        // 관리자 페이지 설명
        $this->method_description = __('고객이 은행 계좌로 직접 입금하는 방식', 'wc-custom-fields');
        
        // 지원 기능
        $this->supports = array(
            'products',
            'refunds'
        );
        
        // 설정 필드 로드
        $this->init_form_fields();
        $this->init_settings();
        
        // 설정값 가져오기
        $this->title = $this->get_option('title');
        $this->description = $this->get_option('description');
        $this->instructions = $this->get_option('instructions');
        $this->account_details = $this->get_option('account_details');
        
        // 설정 저장 훅
        add_action('woocommerce_update_options_payment_gateways_' . $this->id, 
            array($this, 'process_admin_options'));
        
        // 주문 완료 이메일에 계좌 정보 추가
        add_action('woocommerce_email_before_order_table', 
            array($this, 'email_instructions'), 10, 3);
    }
    
    public function init_form_fields() {
        $this->form_fields = array(
            'enabled' => array(
                'title' => __('활성화', 'wc-custom-fields'),
                'type' => 'checkbox',
                'label' => __('무통장입금 결제 활성화', 'wc-custom-fields'),
                'default' => 'no'
            ),
            'title' => array(
                'title' => __('제목', 'wc-custom-fields'),
                'type' => 'text',
                'description' => __('결제 수단 선택 시 표시되는 제목', 'wc-custom-fields'),
                'default' => __('무통장입금', 'wc-custom-fields'),
                'desc_tip' => true
            ),
            'description' => array(
                'title' => __('설명', 'wc-custom-fields'),
                'type' => 'textarea',
                'description' => __('결제 수단 선택 시 표시되는 설명', 'wc-custom-fields'),
                'default' => __('아래 계좌로 입금해주세요.', 'wc-custom-fields'),
                'desc_tip' => true
            ),
            'instructions' => array(
                'title' => __('입금 안내', 'wc-custom-fields'),
                'type' => 'textarea',
                'description' => __('주문 완료 페이지에 표시될 안내 문구', 'wc-custom-fields'),
                'default' => __('입금 확인 후 상품이 발송됩니다.', 'wc-custom-fields'),
                'desc_tip' => true
            ),
            'account_details' => array(
                'title' => __('계좌 정보', 'wc-custom-fields'),
                'type' => 'textarea',
                'description' => __('은행명, 계좌번호, 예금주를 입력하세요', 'wc-custom-fields'),
                'default' => '',
                'desc_tip' => true,
                'placeholder' => "국민은행\n123-456-789012\n홍길동"
            )
        );
    }
    
    public function payment_fields() {
        // 결제 페이지에 표시될 내용
        if ($this->description) {
            echo wpautop(wptexturize($this->description));
        }
        
        if ($this->account_details) {
            echo '<div class="bank-account-details">';
            echo '<h4>' . __('입금 계좌 정보', 'wc-custom-fields') . '</h4>';
            echo '<pre>' . esc_html($this->account_details) . '</pre>';
            echo '</div>';
        }
    }
    
    public function process_payment($order_id) {
        $order = wc_get_order($order_id);
        
        // 주문 상태를 '입금 대기'로 변경
        $order->update_status('on-hold', __('무통장입금 대기 중', 'wc-custom-fields'));
        
        // 장바구니 비우기
        WC()->cart->empty_cart();
        
        // 주문 완료 페이지로 리다이렉트
        return array(
            'result' => 'success',
            'redirect' => $this->get_return_url($order)
        );
    }
    
    public function email_instructions($order, $sent_to_admin, $plain_text = false) {
        // 관리자에게 보내는 이메일이 아니고, 무통장입금 주문이며, 입금 대기 상태일 때
        if (!$sent_to_admin && 
            $this->id === $order->get_payment_method() && 
            $order->has_status('on-hold')) {
            
            if ($this->instructions) {
                echo wpautop(wptexturize($this->instructions)) . PHP_EOL;
            }
            
            if ($this->account_details) {
                echo '<h3>' . __('입금 계좌', 'wc-custom-fields') . '</h3>' . PHP_EOL;
                echo '<pre>' . esc_html($this->account_details) . '</pre>' . PHP_EOL;
            }
        }
    }
    
    // 환불 처리
    public function process_refund($order_id, $amount = null, $reason = '') {
        $order = wc_get_order($order_id);
        
        if (!$order) {
            return false;
        }
        
        // 실제 환불 로직 구현
        // 예: 관리자에게 알림 전송, 환불 요청 기록 등
        
        $order->add_order_note(
            sprintf(__('환불 요청: %s (사유: %s)', 'wc-custom-fields'), 
            wc_price($amount), 
            $reason)
        );
        
        return true;
    }
}

// 게이트웨이 등록
function add_custom_bank_gateway($gateways) {
    $gateways[] = 'WC_Gateway_Custom_Bank';
    return $gateways;
}
add_filter('woocommerce_payment_gateways', 'add_custom_bank_gateway');

class WC_Custom_Database {
    
    private $table_name;
    private $version = '1.0';
    
    public function __construct() {
        global $wpdb;
        $this->table_name = $wpdb->prefix . 'wc_product_review_stats';
        
        // 플러그인 활성화 시 테이블 생성
        register_activation_hook(__FILE__, array($this, 'create_table'));
    }
    
    public function create_table() {
        global $wpdb;
        
        $charset_collate = $wpdb->get_charset_collate();
        
        $sql = "CREATE TABLE IF NOT EXISTS {$this->table_name} (
            id bigint(20) NOT NULL AUTO_INCREMENT,
            product_id bigint(20) NOT NULL,
            total_reviews int(11) DEFAULT 0,
            average_rating decimal(3,2) DEFAULT 0.00,
            five_star int(11) DEFAULT 0,
            four_star int(11) DEFAULT 0,
            three_star int(11) DEFAULT 0,
            two_star int(11) DEFAULT 0,
            one_star int(11) DEFAULT 0,
            last_updated datetime DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
            PRIMARY KEY  (id),
            KEY product_id (product_id)
        ) $charset_collate;";
        
        require_once(ABSPATH . 'wp-admin/includes/upgrade.php');
        dbDelta($sql);
        
        // 버전 정보 저장
        add_option('wc_custom_db_version', $this->version);
    }
    
    // 리뷰 통계 업데이트
    public function update_review_stats($product_id) {
        global $wpdb;
        
        // 제품의 모든 리뷰 가져오기
        $reviews = get_comments(array(
            'post_id' => $product_id,
            'status' => 'approve',
            'type' => 'review'
        ));
        
        $stats = array(
            'total_reviews' => count($reviews),
            'five_star' => 0,
            'four_star' => 0,
            'three_star' => 0,
            'two_star' => 0,
            'one_star' => 0,
            'total_rating' => 0
        );
        
        // 별점별 카운트
        foreach ($reviews as $review) {
            $rating = intval(get_comment_meta($review->comment_ID, 'rating', true));
            $stats['total_rating'] += $rating;
            
            switch ($rating) {
                case 5: $stats['five_star']++; break;
                case 4: $stats['four_star']++; break;
                case 3: $stats['three_star']++; break;
                case 2: $stats['two_star']++; break;
                case 1: $stats['one_star']++; break;
            }
        }
        
        // 평균 계산
        $average_rating = $stats['total_reviews'] > 0 
            ? round($stats['total_rating'] / $stats['total_reviews'], 2) 
            : 0;
        
        // 데이터베이스에 저장
        $existing = $wpdb->get_var($wpdb->prepare(
            "SELECT id FROM {$this->table_name} WHERE product_id = %d",
            $product_id
        ));
        
        $data = array(
            'product_id' => $product_id,
            'total_reviews' => $stats['total_reviews'],
            'average_rating' => $average_rating,
            'five_star' => $stats['five_star'],
            'four_star' => $stats['four_star'],
            'three_star' => $stats['three_star'],
            'two_star' => $stats['two_star'],
            'one_star' => $stats['one_star']
        );
        
        if ($existing) {
            // 업데이트
            $wpdb->update(
                $this->table_name,
                $data,
                array('product_id' => $product_id),
                array('%d', '%d', '%f', '%d', '%d', '%d', '%d', '%d'),
                array('%d')
            );
        } else {
            // 새로 삽입
            $wpdb->insert(
                $this->table_name,
                $data,
                array('%d', '%d', '%f', '%d', '%d', '%d', '%d', '%d')
            );
        }
    }
    
    // 통계 조회
    public function get_review_stats($product_id) {
        global $wpdb;
        
        return $wpdb->get_row($wpdb->prepare(
            "SELECT * FROM {$this->table_name} WHERE product_id = %d",
            $product_id
        ), ARRAY_A);
    }
    
    // 인기 제품 조회 (리뷰 많은 순)
    public function get_most_reviewed_products($limit = 10) {
        global $wpdb;
        
        return $wpdb->get_results($wpdb->prepare(
            "SELECT product_id, total_reviews, average_rating 
            FROM {$this->table_name} 
            ORDER BY total_reviews DESC 
            LIMIT %d",
            $limit
        ), ARRAY_A);
    }
}

$wc_custom_db = new WC_Custom_Database();

// 리뷰 작성/수정/삭제 시 통계 업데이트
add_action('comment_post', function($comment_id, $approved) {
    $comment = get_comment($comment_id);
    if ($comment->comment_type === 'review' && $approved === 1) {
        global $wc_custom_db;
        $wc_custom_db->update_review_stats($comment->comment_post_ID);
    }
}, 10, 2);

add_action('edit_comment', function($comment_id) {
    $comment = get_comment($comment_id);
    if ($comment->comment_type === 'review') {
        global $wc_custom_db;
        $wc_custom_db->update_review_stats($comment->comment_post_ID);
    }
});

add_action('delete_comment', function($comment_id) {
    $comment = get_comment($comment_id);
    if ($comment->comment_type === 'review') {
        global $wc_custom_db;
        $wc_custom_db->update_review_stats($comment->comment_post_ID);
    }
});

class WC_Review_Stats_Widget extends WP_Widget {
    
    public function __construct() {
        parent::__construct(
            'wc_review_stats_widget',
            __('제품 리뷰 통계', 'wc-custom-fields'),
            array('description' => __('제품의 리뷰 통계를 표시합니다', 'wc-custom-fields'))
        );
    }
    
    public function widget($args, $instance) {
        global $product, $wc_custom_db;
        
        if (!is_product() || !$product) {
            return;
        }
        
        $stats = $wc_custom_db->get_review_stats($product->get_id());
        
        if (!$stats || $stats['total_reviews'] == 0) {
            return;
        }
        
        echo $args['before_widget'];
        
        if (!empty($instance['title'])) {
            echo $args['before_title'] . apply_filters('widget_title', $instance['title']) . $args['after_title'];
        }
        
        ?>
        <div class="review-stats-widget">
            <div class="average-rating">
                <span class="rating-number"><?php echo $stats['average_rating']; ?></span>
                <span class="rating-stars">
                    <?php echo wc_get_rating_html($stats['average_rating']); ?>
                </span>
                <span class="total-reviews">
                    <?php printf(__('%d개의 리뷰', 'wc-custom-fields'), $stats['total_reviews']); ?>
                </span>
            </div>
            
            <div class="rating-breakdown">
                <?php
                $ratings = array(
                    5 => $stats['five_star'],
                    4 => $stats['four_star'],
                    3 => $stats['three_star'],
                    2 => $stats['two_star'],
                    1 => $stats['one_star']
                );
                
                foreach ($ratings as $star => $count) {
                    $percentage = $stats['total_reviews'] > 0 
                        ? ($count / $stats['total_reviews']) * 100 
                        : 0;
                    ?>
                    <div class="rating-row">
                        <span class="star-label"><?php echo $star; ?>⭐</span>
                        <div class="rating-bar">
                            <div class="rating-fill" style="width: <?php echo $percentage; ?>%"></div>
                        </div>
                        <span class="rating-count"><?php echo $count; ?></span>
                    </div>
                    <?php
                }
                ?>
            </div>
        </div>
        <?php
        
        echo $args['after_widget'];
    }
    
    public function form($instance) {
        $title = !empty($instance['title']) ? $instance['title'] : __('리뷰 통계', 'wc-custom-fields');
        ?>
        <p>
            <label for="<?php echo $this->get_field_id('title'); ?>">
                <?php _e('제목:', 'wc-custom-fields'); ?>
            </label>
            <input class="widefat" 
                   id="<?php echo $this->get_field_id('title'); ?>" 
                   name="<?php echo $this->get_field_name('title'); ?>" 
                   type="text" 
                   value="<?php echo esc_attr($title); ?>">
        </p>
        <?php
    }
    
    public function update($new_instance, $old_instance) {
        $instance = array();
        $instance['title'] = (!empty($new_instance['title'])) 
            ? sanitize_text_field($new_instance['title']) 
            : '';
        return $instance;
    }
}

// 위젯 등록
function register_review_stats_widget() {
    register_widget('WC_Review_Stats_Widget');
}
add_action('widgets_init', 'register_review_stats_widget');

class WC_Custom_REST_API {
    
    private $namespace = 'wc-custom/v1';
    
    public function __construct() {
        add_action('rest_api_init', array($this, 'register_routes'));
    }
    
    public function register_routes() {
        // 인기 제품 조회
        register_rest_route($this->namespace, '/popular-products', array(
            'methods' => 'GET',
            'callback' => array($this, 'get_popular_products'),
            'permission_callback' => '__return_true',
            'args' => array(
                'category' => array(
                    'required' => false,
                    'type' => 'string',
                    'description' => '카테고리 슬러그'
                ),
                'limit' => array(
                    'required' => false,
                    'type' => 'integer',
                    'default' => 10,
                    'minimum' => 1,
                    'maximum' => 100
                )
            )
        ));
        
        // 제품 상세 통계
        register_rest_route($this->namespace, '/product-stats/(?P<id>\d+)', array(
            'methods' => 'GET',
            'callback' => array($this, 'get_product_stats'),
            'permission_callback' => '__return_true',
            'args' => array(
                'id' => array(
                    'required' => true,
                    'type' => 'integer',
                    'description' => '제품 ID'
                )
            )
        ));
        
        // 장바구니에 제품 추가 (인증 필요)
        register_rest_route($this->namespace, '/cart/add', array(
            'methods' => 'POST',
            'callback' => array($this, 'add_to_cart'),
            'permission_callback' => array($this, 'check_authentication'),
            'args' => array(
                'product_id' => array(
                    'required' => true,
                    'type' => 'integer'
                ),
                'quantity' => array(
                    'required' => false,
                    'type' => 'integer',
                    'default' => 1
                )
            )
        ));
    }
    
    public function get_popular_products($request) {
        $category = $request->get_param('category');
        $limit = $request->get_param('limit');
        
        $args = array(
            'post_type' => 'product',
            'posts_per_page' => $limit,
            'meta_key' => 'total_sales',
            'orderby' => 'meta_value_num',
            'order' => 'DESC'
        );
        
        // 카테고리 필터
        if ($category) {
            $args['tax_query'] = array(
                array(
                    'taxonomy' => 'product_cat',
                    'field' => 'slug',
                    'terms' => $category
                )
            );
        }
        
        $query = new WP_Query($args);
        $products = array();
        
        if ($query->have_posts()) {
            while ($query->have_posts()) {
                $query->the_post();
                $product = wc_get_product(get_the_ID());
                
                $products[] = array(
                    'id' => $product->get_id(),
                    'name' => $product->get_name(),
                    'price' => $product->get_price(),
                    'regular_price' => $product->get_regular_price(),
                    'sale_price' => $product->get_sale_price(),
                    'on_sale' => $product->is_on_sale(),
                    'stock_status' => $product->get_stock_status(),
                    'image' => wp_get_attachment_url($product->get_image_id()),
                    'permalink' => get_permalink($product->get_id()),
                    'total_sales' => $product->get_total_sales(),
                    'average_rating' => $product->get_average_rating(),
                    'rating_count' => $product->get_rating_count()
                );
            }
            wp_reset_postdata();
        }
        
        return new WP_REST_Response(array(
            'success' => true,
            'data' => $products,
            'total' => count($products)
        ), 200);
    }
    
    public function get_product_stats($request) {
        global $wc_custom_db;
        
        $product_id = $request->get_param('id');
        $product = wc_get_product($product_id);
        
        if (!$product) {
            return new WP_Error(
                'product_not_found',
                __('제품을 찾을 수 없습니다', 'wc-custom-fields'),
                array('status' => 404)
            );
        }
        
        $stats = $wc_custom_db->get_review_stats($product_id);
        
        $data = array(
            'product_id' => $product_id,
            'name' => $product->get_name(),
            'total_sales' => $product->get_total_sales(),
            'stock_quantity' => $product->get_stock_quantity(),
            'reviews' => $stats ? $stats : array(
                'total_reviews' => 0,
                'average_rating' => 0
            ),
            'views' => get_post_meta($product_id, 'product_views', true) ?: 0
        );
        
        return new WP_REST_Response(array(
            'success' => true,
            'data' => $data
        ), 200);
    }
    
    public function add_to_cart($request) {
        $product_id = $request->get_param('product_id');
        $quantity = $request->get_param('quantity');
        
        // 제품 존재 확인
        $product = wc_get_product($product_id);
        if (!$product) {
            return new WP_Error(
                'invalid_product',
                __('유효하지 않은 제품입니다', 'wc-custom-fields'),
                array('status' => 400)
            );
        }
        
        // 재고 확인
        if (!$product->is_in_stock()) {
            return new WP_Error(
                'out_of_stock',
                __('품절된 상품입니다', 'wc-custom-fields'),
                array('status' => 400)
            );
        }
        
        // 장바구니에 추가
        $cart_item_key = WC()->cart->add_to_cart($product_id, $quantity);
        
        if ($cart_item_key) {
            return new WP_REST_Response(array(
                'success' => true,
                'message' => __('장바구니에 추가되었습니다', 'wc-custom-fields'),
                'cart_item_key' => $cart_item_key,
                'cart_total' => WC()->cart->get_cart_contents_count()
            ), 200);
        } else {
            return new WP_Error(
                'add_to_cart_failed',
                __('장바구니 추가에 실패했습니다', 'wc-custom-fields'),
                array('status' => 500)
            );
        }
    }
    
    public function check_authentication($request) {
        // JWT 토큰이나 API 키 검증 로직
        // 여기서는 간단히 로그인 여부만 체크
        return is_user_logged_in();
    }
}

new WC_Custom_REST_API();

# 인기 제품 조회
curl -X GET "https://yoursite.com/wp-json/wc-custom/v1/popular-products?category=electronics&limit=5"

# 제품 통계 조회
curl -X GET "https://yoursite.com/wp-json/wc-custom/v1/product-stats/123"

# 장바구니에 추가 (쿠키 필요)
curl -X POST "https://yoursite.com/wp-json/wc-custom/v1/cart/add" \
  -H "Content-Type: application/json" \
  -d '{"product_id": 123, "quantity": 2}' \
  --cookie "wordpress_logged_in_xxx=..."

// ❌ 나쁜 예: 루프 안에서 반복 쿼리
foreach ($product_ids as $id) {
    $product = wc_get_product($id); // 매번 DB 조회!
    echo $product->get_name();
}

// ✅ 좋은 예: 한 번에 조회
$products = wc_get_products(array(
    'include' => $product_ids,
    'limit' => -1
));

foreach ($products as $product) {
    echo $product->get_name();
}

function get_featured_products_cached() {
    $cache_key = 'featured_products_list';
    $products = get_transient($cache_key);
    
    if (false === $products) {
        // 캐시가 없으면 DB에서 조회
        $products = wc_get_products(array(
            'featured' => true,
            'limit' => 10,
            'orderby' => 'popularity'
        ));
        
        // 1시간 동안 캐시
        set_transient($cache_key, $products, HOUR_IN_SECONDS);
    }
    
    return $products;
}

// 제품 업데이트 시 캐시 삭제
add_action('woocommerce_update_product', function($product_id) {
    delete_transient('featured_products_list');
});

function get_product_with_cache($product_id) {
    $cache_key = 'product_data_' . $product_id;
    $product_data = wp_cache_get($cache_key, 'products');
    
    if (false === $product_data) {
        $product = wc_get_product($product_id);
        
        $product_data = array(
            'id' => $product->get_id(),
            'name' => $product->get_name(),
            'price' => $product->get_price(),
            'stock' => $product->get_stock_status()
        );
        
        wp_cache_set($cache_key, $product_data, 'products', 3600);
    }
    
    return $product_data;
}

// 이미지 Lazy Loading 추가
add_filter('wp_get_attachment_image_attributes', function($attr) {
    if (!is_admin()) {
        $attr['loading'] = 'lazy';
    }
    return $attr;
});

// WebP 지원
add_filter('wp_generate_attachment_metadata', function($metadata, $attachment_id) {
    $file = get_attached_file($attachment_id);
    
    if (function_exists('imagewebp')) {
        $image = wp_get_image_editor($file);
        
        if (!is_wp_error($image)) {
            $webp_file = preg_replace('/\.(jpg|jpeg|png)$/i', '.webp', $file);
            $image->save($webp_file, 'image/webp');
        }
    }
    
    return $metadata;
}, 10, 2);

// 특정 페이지에서만 스크립트 로드
function enqueue_conditional_scripts() {
    // 제품 페이지가 아니면 제품 관련 JS 로드 안 함
    if (!is_product()) {
        wp_dequeue_script('wc-single-product');
        wp_dequeue_script('zoom');
        wp_dequeue_script('flexslider');
    }
    
    // 장바구니/결제 페이지가 아니면 결제 스크립트 로드 안 함
    if (!is_cart() && !is_checkout()) {
        wp_dequeue_script('wc-cart');
        wp_dequeue_script('wc-checkout');
    }
}
add_action('wp_enqueue_scripts', 'enqueue_conditional_scripts', 100);

// 주간 데이터베이스 정리 크론잡
function schedule_db_cleanup() {
    if (!wp_next_scheduled('weekly_db_cleanup')) {
        wp_schedule_event(time(), 'weekly', 'weekly_db_cleanup');
    }
}
add_action('wp', 'schedule_db_cleanup');

function perform_db_cleanup() {
    global $wpdb;
    
    // 오래된 트랜지언트 삭제
    $wpdb->query("DELETE FROM {$wpdb->options} 
                  WHERE option_name LIKE '_transient_%' 
                  AND option_value < UNIX_TIMESTAMP()");
    
    // 오래된 장바구니 세션 삭제 (30일 이상)
    $wpdb->query("DELETE FROM {$wpdb->prefix}woocommerce_sessions 
                  WHERE session_expiry < UNIX_TIMESTAMP() - (30 * 24 * 60 * 60)");
    
    // 테이블 최적화
    $tables = $wpdb->get_results("SHOW TABLES", ARRAY_N);
    foreach ($tables as $table) {
        $wpdb->query("OPTIMIZE TABLE {$table[0]}");
    }
}
add_action('weekly_db_cleanup', 'perform_db_cleanup');

// 사용자 입력 처리 예제
function process_custom_form_data() {
    // Nonce 검증 (CSRF 방지)
    if (!isset($_POST['custom_nonce']) || 
        !wp_verify_nonce($_POST['custom_nonce'], 'custom_form_action')) {
        wp_die(__('보안 검증 실패', 'wc-custom-fields'));
    }
    
    // 권한 확인
    if (!current_user_can('edit_posts')) {
        wp_die(__('권한이 없습니다', 'wc-custom-fields'));
    }
    
    // 입력값 살균
    $text_field = isset($_POST['text_field']) 
        ? sanitize_text_field($_POST['text_field']) 
        : '';
    
    $email = isset($_POST['email']) 
        ? sanitize_email($_POST['email']) 
        : '';
    
    $url = isset($_POST['url']) 
        ? esc_url_raw($_POST['url']) 
        : '';
    
    $number = isset($_POST['number']) 
        ? absint($_POST['number']) 
        : 0;
    
    // HTML 허용 시 (제한적으로)
    $allowed_html = array(
        'a' => array('href' => array(), 'title' => array()),
        'br' => array(),
        'em' => array(),
        'strong' => array()
    );
    $html_content = isset($_POST['content']) 
        ? wp_kses($_POST['content'], $allowed_html) 
        : '';
    
    // 데이터 처리...
}

// 출력 시 이스케이프
function display_user_content($content) {
    // HTML 출력
    echo wp_kses_post($content);
    
    // 일반 텍스트
    echo esc_html($text);
    
    // 속성값
    echo '<div data-value="' . esc_attr($value) . '">';
    
    // URL
    echo '<a href="' . esc_url($url) . '">';
    
    // JavaScript
    echo '<script>var data = ' . wp_json_encode($data) . ';</script>';
}

// ❌ 위험한 코드
$user_id = $_GET['user_id'];
$query = "SELECT * FROM {$wpdb->users} WHERE ID = $user_id";
$result = $wpdb->get_results($query);

// ✅ 안전한 코드
$user_id = isset($_GET['user_id']) ? absint($_GET['user_id']) : 0;
$query = $wpdb->prepare(
    "SELECT * FROM {$wpdb->users} WHERE ID = %d",
    $user_id
);
$result = $wpdb->get_results($query);

// 복잡한 쿼리 예제
$product_ids = array(1, 2, 3, 4, 5);
$placeholders = implode(',', array_fill(0, count($product_ids), '%d'));
$query = $wpdb->prepare(
    "SELECT * FROM {$wpdb->posts} 
    WHERE ID IN ($placeholders) 
    AND post_type = %s 
    AND post_status = %s",
    array_merge($product_ids, array('product', 'publish'))
);
$products = $wpdb->get_results($query);

function secure_file_upload($file) {
    // 파일 타입 검증
    $allowed_types = array('jpg', 'jpeg', 'png', 'gif', 'pdf');
    $file_ext = strtolower(pathinfo($file['name'], PATHINFO_EXTENSION));
    
    if (!in_array($file_ext, $allowed_types)) {
        return new WP_Error('invalid_file_type', 
            __('허용되지 않는 파일 형식입니다', 'wc-custom-fields'));
    }
    
    // MIME 타입 검증
    $finfo = finfo_open(FILEINFO_MIME_TYPE);
    $mime_type = finfo_file($finfo, $file['tmp_name']);
    finfo_close($finfo);
    
    $allowed_mimes = array(
        'image/jpeg',
        'image/png',
        'image/gif',
        'application/pdf'
    );
    
    if (!in_array($mime_type, $allowed_mimes)) {
        return new WP_Error('invalid_mime_type', 
            __('파일 내용이 확장자와 일치하지 않습니다', 'wc-custom-fields'));
    }
    
    // 파일 크기 제한 (5MB)
    $max_size = 5 * 1024 * 1024;
    if ($file['size'] > $max_size) {
        return new WP_Error('file_too_large', 
            __('파일 크기는 5MB를 초과할 수 없습니다', 'wc-custom-fields'));
    }
    
    // 파일명 살균
    $file['name'] = sanitize_file_name($file['name']);
    
    // 워드프레스 업로드 처리
    require_once(ABSPATH . 'wp-admin/includes/file.php');
    $upload = wp_handle_upload($file, array('test_form' => false));
    
    if (isset($upload['error'])) {
        return new WP_Error('upload_failed', $upload['error']);
    }
    
    return $upload;
}

// wp-config.php에 정의
define('CUSTOM_API_KEY', 'your-secret-key-here');
define('CUSTOM_API_SECRET', 'your-secret-here');

// 플러그인에서 사용
$api_key = defined('CUSTOM_API_KEY') ? CUSTOM_API_KEY : '';

// 또는 옵션으로 저장 (암호화 권장)
function save_encrypted_api_key($key) {
    $encrypted = base64_encode($key); // 실제로는 더 강력한 암호화 사용
    update_option('encrypted_api_key', $encrypted);
}

function get_decrypted_api_key() {
    $encrypted = get_option('encrypted_api_key');
    return base64_decode($encrypted);
}

class API_Rate_Limiter {
    
    private $max_requests = 100; // 시간당 최대 요청 수
    private $time_window = 3600; // 1시간
    
    public function check_rate_limit($user_id) {
        $transient_key = 'api_requests_' . $user_id;
        $requests = get_transient($transient_key);
        
        if (false === $requests) {
            $requests = array();
        }
        
        // 현재 시간 윈도우 내의 요청만 카운트
        $current_time = time();
        $requests = array_filter($requests, function($timestamp) use ($current_time) {
            return ($current_time - $timestamp) < $this->time_window;
        });
        
        // 제한 초과 확인
        if (count($requests) >= $this->max_requests) {
            return new WP_Error(
                'rate_limit_exceeded',
                __('요청 한도를 초과했습니다. 잠시 후 다시 시도해주세요.', 'wc-custom-fields'),
                array('status' => 429)
            );
        }
        
        // 새 요청 기록
        $requests[] = $current_time;
        set_transient($transient_key, $requests, $this->time_window);
        
        return true;
    }
}

// REST API에 적용
add_filter('rest_pre_dispatch', function($result, $server, $request) {
    $limiter = new API_Rate_Limiter();
    $user_id = get_current_user_id() ?: $_SERVER['REMOTE_ADDR'];
    
    $check = $limiter->check_rate_limit($user_id);
    if (is_wp_error($check)) {
        return $check;
    }
    
    return $result;
}, 10, 3);

// tests/test-product-fields.php
class Test_Product_Fields extends WP_UnitTestCase {
    
    private $product_id;
    
    public function setUp() {
        parent::setUp();
        
        // 테스트용 제품 생성
        $this->product_id = wp_insert_post(array(
            'post_title' => 'Test Product',
            'post_type' => 'product',
            'post_status' => 'publish'
        ));
    }
    
    public function tearDown() {
        // 테스트 후 정리
        wp_delete_post($this->product_id, true);
        parent::tearDown();
    }
    
    public function test_custom_field_save() {
        // 커스텀 필드 저장
        update_post_meta($this->product_id, '_custom_text_field', 'Test Value');
        
        // 값 확인
        $value = get_post_meta($this->product_id, '_custom_text_field', true);
        $this->assertEquals('Test Value', $value);
    }
    
    public function test_custom_field_sanitization() {
        // XSS 시도
        $malicious_input = '<script>alert("XSS")</script>';
        $sanitized = sanitize_text_field($malicious_input);
        
        // 스크립트 태그가 제거되었는지 확인
        $this->assertNotContains('<script>', $sanitized);
    }
    
    public function test_product_stats_calculation() {
        global $wc_custom_db;
        
        // 테스트 리뷰 추가
        for ($i = 1; $i <= 5; $i++) {
            $comment_id = wp_insert_comment(array(
                'comment_post_ID' => $this->product_id,
                'comment_content' => 'Test review ' . $i,
                'comment_type' => 'review',
                'comment_approved' => 1
            ));
            
            add_comment_meta($comment_id, 'rating', $i);
        }
        
        // 통계 업데이트
        $wc_custom_db->update_review_stats($this->product_id);
        
        // 통계 확인
        $stats = $wc_custom_db->get_review_stats($this->product_id);
        
        $this->assertEquals(5, $stats['total_reviews']);
        $this->assertEquals(3.0, $stats['average_rating']); // (1+2+3+4+5)/5 = 3
    }
}

// 테스트 실행
// vendor/bin/phpunit tests/test-product-fields.php

class WC_Custom_Logger {
    
    private static $log_file;
    
    public static function init() {
        $upload_dir = wp_upload_dir();
        self::$log_file = $upload_dir['basedir'] . '/wc-custom-logs/debug.log';
        
        // 로그 디렉토리 생성
        $log_dir = dirname(self::$log_file);
        if (!file_exists($log_dir)) {
            wp_mkdir_p($log_dir);
        }
    }
    
    public static function log($message, $level = 'INFO') {
        if (!self::$log_file) {
            self::init();
        }
        
        $timestamp = date('Y-m-d H:i:s');
        $formatted_message = "[{$timestamp}] [{$level}] {$message}" . PHP_EOL;
        
        error_log($formatted_message, 3, self::$log_file);
    }
    
    public static function debug($message) {
        if (defined('WP_DEBUG') && WP_DEBUG) {
            self::log($message, 'DEBUG');
        }
    }
    
    public static function error($message) {
        self::log($message, 'ERROR');
    }
    
    public static function info($message) {
        self::log($message, 'INFO');
    }
}

// 사용 예제
WC_Custom_Logger::debug('제품 ID: ' . $product_id);
WC_Custom_Logger::info('결제 처리 시작');
WC_Custom_Logger::error('API 호출 실패: ' . $error_message);

// 개발 모드 확인 함수
function is_dev_mode() {
    return defined('WC_CUSTOM_DEV_MODE') && WC_CUSTOM_DEV_MODE;
}

// 개발 모드에서만 실행되는 코드
if (is_dev_mode()) {
    // 상세한 에러 메시지 표시
    add_filter('woocommerce_add_error', function($error) {
        $trace = debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS, 5);
        $error .= '<pre>' . print_r($trace, true) . '</pre>';
        return $error;
    });
    
    // 쿼리 로깅
    add_action('shutdown', function() {
        global $wpdb;
        WC_Custom_Logger::debug('Total Queries: ' . $wpdb->num_queries);
        WC_Custom_Logger::debug('Queries: ' . print_r($wpdb->queries, true));
    });
}

// 전역 에러 핸들러
function custom_error_handler($errno, $errstr, $errfile, $errline) {
    $error_types = array(
        E_ERROR => 'ERROR',
        E_WARNING => 'WARNING',
        E_NOTICE => 'NOTICE',
        E_USER_ERROR => 'USER_ERROR',
        E_USER_WARNING => 'USER_WARNING',
        E_USER_NOTICE => 'USER_NOTICE'
    );
    
    $type = isset($error_types[$errno]) ? $error_types[$errno] : 'UNKNOWN';
    
    $message = sprintf(
        "[%s] %s in %s on line %d",
        $type,
        $errstr,
        $errfile,
        $errline
    );
    
    WC_Custom_Logger::error($message);
    
    // 개발 모드가 아니면 사용자에게 친절한 메시지 표시
    if (!is_dev_mode() && $errno === E_USER_ERROR) {
        wp_die(__('죄송합니다. 일시적인 오류가 발생했습니다. 잠시 후 다시 시도해주세요.', 'wc-custom-fields'));
    }
    
    return true;
}

set_error_handler('custom_error_handler');

// 예외 핸들러
function custom_exception_handler($exception) {
    $message = sprintf(
        "Uncaught Exception: %s in %s on line %d\nStack trace:\n%s",
        $exception->getMessage(),
        $exception->getFile(),
        $exception->getLine(),
        $exception->getTraceAsString()
    );
    
    WC_Custom_Logger::error($message);
    
    if (!is_dev_mode()) {
        wp_die(__('죄송합니다. 예기치 않은 오류가 발생했습니다.', 'wc-custom-fields'));
    }
}

set_exception_handler('custom_exception_handler');

=== WooCommerce Custom Product Fields ===
Contributors: yourname
Tags: woocommerce, custom fields, product, ecommerce
Requires at least: 5.8
Tested up to: 6.4
Requires PHP: 7.4
Stable tag: 1.0.0
License: GPLv2 or later
License URI: https://www.gnu.org/licenses/gpl-2.0.html

제품에 커스텀 필드를 추가하는 강력한 WooCommerce 확장 플러그인

== Description ==

WooCommerce Custom Product Fields는 제품 페이지에 다양한 커스텀 필드를 추가할 수 있게 해주는 플러그인입니다.

**주요 기능:**

* 텍스트, 숫자, 셀렉트, 체크박스 등 다양한 필드 타입 지원
* 관리자 페이지에서 쉽게 필드 관리
* 프론트엔드에 자동으로 표시
* 완전한 다국어 지원
* 개발자 친화적인 훅과 필터 제공

**사용 예시:**

* 배송 소요일 표시
* 제품 등급 표시
* 특별 서비스 안내
* 추가 정보 제공

== Installation ==

1. 플러그인 파일을 `/wp-content/plugins/wc-custom-fields` 디렉토리에 업로드하거나,
   워드프레스 관리자 페이지에서 직접 설치하세요.
2. 플러그인 메뉴에서 플러그인을 활성화하세요.
3. WooCommerce > 설정 > 제품 탭에서 설정을 조정하세요.

== Frequently Asked Questions ==

= WooCommerce가 필수인가요? =

네, 이 플러그인은 WooCommerce 5.0 이상이 필요합니다.

= 필드를 더 추가할 수 있나요? =

네, 개발자 문서를 참고하여 커스텀 필드를 추가할 수 있습니다.

= 다국어를 지원하나요? =

네, WPML과 Polylang과 완벽하게 호환됩니다.

== Screenshots ==

1. 관리자 제품 편집 페이지의 커스텀 필드
2. 프론트엔드 제품 페이지 표시
3. 설정 페이지

== Changelog ==

= 1.0.0 =
* 최초 릴리스
* 기본 필드 타입 지원
* 관리자 인터페이스
* 프론트엔드 표시

== Upgrade Notice ==

= 1.0.0 =
최초 릴리스입니다.

== Developer Documentation ==

**훅 사용 예제:**

`
// 커스텀 필드 추가
add_action('wc_custom_fields_after_fields', function() {
    echo '<div>추가 필드</div>';
});

// 필드 값 필터링
add_filter('wc_custom_field_value', function($value, $field_id) {
    return strtoupper($value);
}, 10, 2);
`

더 자세한 문서는 https://yoursite.com/docs 를 참고하세요.

무료 버전:
- 기본 필드 타입 3개 (텍스트, 숫자, 체크박스)
- 제품당 필드 3개까지
- 커뮤니티 지원

프로 버전 ($49):
- 모든 필드 타입 (10개 이상)
- 무제한 필드
- 조건부 로직
- 필드 그룹
- 이메일 지원

비즈니스 버전 ($149):
- 프로 버전 모든 기능
- 다중 사이트 라이선스
- 우선 지원
- 커스텀 필드 템플릿
- API 액세스

엔터프라이즈 ($499):
- 비즈니스 버전 모든 기능
- 무제한 사이트
- 전화 지원
- 맞춤 개발 1시간 포함
- SLA 보장