PrestaShop/
├── admin/           # 관리자 인터페이스
├── classes/         # 핵심 클래스 (Customer, Product 등)
├── config/          # 설정 파일
├── controllers/     # 컨트롤러
├── modules/         # 모듈 디렉토리 (우리가 개발할 곳!)
├── themes/          # 프론트엔드 테마
└── vendor/          # 외부 라이브러리

# docker-compose.yml 파일 예시
version: '3'
services:
  web:
    image: prestashop/prestashop:1.7
    ports:
      - "8080:80"
    environment:
      - DB_SERVER=db
      - DB_USER=prestashop
      - DB_PASSWD=prestashop
      - DB_NAME=prestashop
      - PS_DOMAIN=localhost:8080
    volumes:
      - ./prestashop:/var/www/html
      - ./modules/customer_segmentation:/var/www/html/modules/customer_segmentation
    depends_on:
      - db
  db:
    image: mysql:5.7
    environment:
      - MYSQL_ROOT_PASSWORD=root
      - MYSQL_DATABASE=prestashop
      - MYSQL_USER=prestashop
      - MYSQL_PASSWORD=prestashop
    volumes:
      - db-data:/var/lib/mysql
volumes:
  db-data:

// Customer 클래스 주요 속성과 메소드
class Customer extends ObjectModel
{
    public $id;
    public $id_shop_group;
    public $id_shop;
    public $id_gender;
    public $id_default_group;
    public $id_lang;
    public $firstname;
    public $lastname;
    public $email;
    public $passwd;
    public $last_passwd_gen;
    public $birthday;
    public $newsletter;
    public $ip_registration_newsletter;
    public $newsletter_date_add;
    public $optin;
    public $website;
    public $company;
    public $siret;
    public $ape;
    public $outstanding_allow_amount;
    public $show_public_prices;
    public $max_payment_days;
    public $secure_key;
    public $note;
    public $active;
    public $is_guest;
    public $deleted;
    public $date_add;
    public $date_upd;
    public $reset_password_token;
    public $reset_password_validity;
    
    // 주요 메소드들
    public static function getCustomersByEmail($email);
    public static function customerExists($email);
    public function getGroups();
    public function getAddresses($id_lang);
    public function getSimpleAddresses();
    public function getLastEmptyCart();
    public function getBoughtProducts();
    // ... 기타 메소드들
}

customer_segmentation/
├── config.xml                 # 모듈 설정 XML
├── customer_segmentation.php  # 메인 모듈 클래스
├── index.php                  # 보안을 위한 빈 인덱스 파일
├── logo.png                   # 모듈 로고
├── controllers/               # 컨트롤러 디렉토리
│   └── admin/                 # 관리자 컨트롤러
│       └── SegmentController.php
├── classes/                   # 모듈 클래스
│   ├── Segment.php
│   ├── SegmentRule.php
│   └── SegmentCustomer.php
├── sql/                       # SQL 설치/제거 스크립트
│   ├── install.php
│   └── uninstall.php
├── views/                     # 뷰 템플릿
│   ├── css/
│   ├── js/
│   └── templates/
│       ├── admin/
│       └── front/
└── translations/              # 다국어 지원

<?php
if (!defined('_PS_VERSION_')) {
    exit;
}

require_once _PS_MODULE_DIR_ . 'customer_segmentation/classes/Segment.php';
require_once _PS_MODULE_DIR_ . 'customer_segmentation/classes/SegmentRule.php';
require_once _PS_MODULE_DIR_ . 'customer_segmentation/classes/SegmentCustomer.php';

class CustomerSegmentation extends Module
{
    public function __construct()
    {
        $this->name = 'customer_segmentation';
        $this->tab = 'advertising_marketing';
        $this->version = '1.0.0';
        $this->author = '당신의 이름';
        $this->need_instance = 0;
        $this->ps_versions_compliancy = [
            'min' => '1.7.0.0',
            'max' => _PS_VERSION_
        ];
        $this->bootstrap = true;

        parent::__construct();

        $this->displayName = $this->l('Customer Segmentation');
        $this->description = $this->l('Create and manage customer segments for targeted marketing.');
        $this->confirmUninstall = $this->l('Are you sure you want to uninstall this module?');
    }

    public function install()
    {
        include(dirname(__FILE__) . '/sql/install.php');
        
        return parent::install() &&
            $this->registerHook('actionCustomerAccountAdd') &&
            $this->registerHook('actionOrderStatusUpdate') &&
            $this->registerHook('displayBackOfficeHeader') &&
            $this->installTab();
    }

    public function uninstall()
    {
        include(dirname(__FILE__) . '/sql/uninstall.php');
        
        return parent::uninstall() &&
            $this->uninstallTab();
    }
    
    // 관리자 메뉴 탭 설치
    private function installTab()
    {
        $tab = new Tab();
        $tab->active = 1;
        $tab->class_name = 'AdminCustomerSegmentation';
        $tab->name = array();
        
        foreach (Language::getLanguages(true) as $lang) {
            $tab->name[$lang['id_lang']] = 'Customer Segmentation';
        }
        
        $tab->id_parent = (int)Tab::getIdFromClassName('AdminParentCustomer');
        $tab->module = $this->name;
        
        return $tab->add();
    }
    
    private function uninstallTab()
    {
        $id_tab = (int)Tab::getIdFromClassName('AdminCustomerSegmentation');
        
        if ($id_tab) {
            $tab = new Tab($id_tab);
            return $tab->delete();
        }
        
        return true;
    }
    
    // 관리자 페이지 설정
    public function getContent()
    {
        // 모듈 설정 페이지 내용 구현
        $output = '';
        
        if (Tools::isSubmit('submit' . $this->name)) {
            // 설정 저장 로직
            $output .= $this->displayConfirmation($this->l('Settings updated'));
        }
        
        return $output . $this->renderForm();
    }
    
    // 설정 폼 렌더링
    protected function renderForm()
    {
        // 모듈 설정 폼 구현
        // ...
    }
    
    // 훅 구현
    public function hookActionCustomerAccountAdd($params)
    {
        // 새 고객 등록 시 세그먼트 처리
    }
    
    public function hookActionOrderStatusUpdate($params)
    {
        // 주문 상태 변경 시 세그먼트 업데이트
    }
    
    public function hookDisplayBackOfficeHeader()
    {
        // 관리자 페이지 CSS/JS 추가
    }
}

<?php
$sql = array();

// 세그먼트 테이블
$sql[] = 'CREATE TABLE IF NOT EXISTS `' . _DB_PREFIX_ . 'customer_segment` (
    `id_segment` int(10) unsigned NOT NULL AUTO_INCREMENT,
    `name` varchar(255) NOT NULL,
    `description` text,
    `active` tinyint(1) unsigned NOT NULL DEFAULT 1,
    `date_add` datetime NOT NULL,
    `date_upd` datetime NOT NULL,
    PRIMARY KEY (`id_segment`)
) ENGINE=' . _MYSQL_ENGINE_ . ' DEFAULT CHARSET=utf8;';

// 세그먼트 규칙 테이블
$sql[] = 'CREATE TABLE IF NOT EXISTS `' . _DB_PREFIX_ . 'customer_segment_rule` (
    `id_segment_rule` int(10) unsigned NOT NULL AUTO_INCREMENT,
    `id_segment` int(10) unsigned NOT NULL,
    `rule_type` varchar(50) NOT NULL,
    `rule_field` varchar(100) NOT NULL,
    `rule_operator` varchar(20) NOT NULL,
    `rule_value` varchar(255) NOT NULL,
    `date_add` datetime NOT NULL,
    `date_upd` datetime NOT NULL,
    PRIMARY KEY (`id_segment_rule`),
    KEY `id_segment` (`id_segment`)
) ENGINE=' . _MYSQL_ENGINE_ . ' DEFAULT CHARSET=utf8;';

// 세그먼트-고객 관계 테이블
$sql[] = 'CREATE TABLE IF NOT EXISTS `' . _DB_PREFIX_ . 'customer_segment_customer` (
    `id_segment` int(10) unsigned NOT NULL,
    `id_customer` int(10) unsigned NOT NULL,
    `date_add` datetime NOT NULL,
    PRIMARY KEY (`id_segment`, `id_customer`)
) ENGINE=' . _MYSQL_ENGINE_ . ' DEFAULT CHARSET=utf8;';

foreach ($sql as $query) {
    if (Db::getInstance()->execute($query) == false) {
        return false;
    }
}

public function install()
{
    include(dirname(__FILE__) . '/sql/install.php');
    
    return parent::install() &&
        // 기존 훅
        $this->registerHook('actionCustomerAccountAdd') &&
        $this->registerHook('actionOrderStatusUpdate') &&
        $this->registerHook('displayBackOfficeHeader') &&
        // 추가 훅
        $this->registerHook('actionCustomerLogin') &&
        $this->registerHook('actionCartSave') &&
        $this->registerHook('actionObjectProductViewedAddAfter') &&
        $this->registerHook('actionEmailSendBefore') &&
        $this->registerHook('actionSearch') &&
        $this->installTab();
}

// 상품 조회 추적
public function hookActionObjectProductViewedAddAfter($params)
{
    // 로그인한 고객만 추적
    if (!$this->context->customer->isLogged()) {
        return;
    }
    
    $id_customer = (int)$this->context->customer->id;
    $id_product = (int)$params['object']->id_product;
    
    // 고객 행동 로그 테이블에 저장
    Db::getInstance()->insert(
        'customer_behavior_log',
        [
            'id_customer' => $id_customer,
            'action_type' => 'product_view',
            'id_reference' => $id_product,
            'date_add' => date('Y-m-d H:i:s')
        ]
    );
    
    // 세그먼트 규칙 평가 및 업데이트
    $this->evaluateCustomerSegments($id_customer);
}

// 고객 행동 로그 테이블
$sql[] = 'CREATE TABLE IF NOT EXISTS `' . _DB_PREFIX_ . 'customer_behavior_log` (
    `id_log` int(10) unsigned NOT NULL AUTO_INCREMENT,
    `id_customer` int(10) unsigned NOT NULL,
    `action_type` varchar(50) NOT NULL,
    `id_reference` int(10) unsigned DEFAULT NULL,
    `data` text,
    `date_add` datetime NOT NULL,
    PRIMARY KEY (`id_log`),
    KEY `id_customer` (`id_customer`),
    KEY `action_type` (`action_type`)
) ENGINE=' . _MYSQL_ENGINE_ . ' DEFAULT CHARSET=utf8;';

<?php
if (!defined('_PS_VERSION_')) {
    exit;
}

class Segment extends ObjectModel
{
    public $id;
    public $name;
    public $description;
    public $active;
    public $date_add;
    public $date_upd;
    
    public static $definition = [
        'table' => 'customer_segment',
        'primary' => 'id_segment',
        'fields' => [
            'name' => ['type' => self::TYPE_STRING, 'validate' => 'isGenericName', 'required' => true, 'size' => 255],
            'description' => ['type' => self::TYPE_HTML, 'validate' => 'isCleanHtml'],
            'active' => ['type' => self::TYPE_BOOL, 'validate' => 'isBool', 'required' => true],
            'date_add' => ['type' => self::TYPE_DATE, 'validate' => 'isDate'],
            'date_upd' => ['type' => self::TYPE_DATE, 'validate' => 'isDate'],
        ],
    ];
    
    // 세그먼트에 속한 고객 수 가져오기
    public function getCustomerCount()
    {
        return Db::getInstance()->getValue(
            'SELECT COUNT(*) FROM `' . _DB_PREFIX_ . 'customer_segment_customer`
            WHERE `id_segment` = ' . (int)$this->id
        );
    }
    
    // 세그먼트에 속한 고객 목록 가져오기
    public function getCustomers($limit = 0, $offset = 0)
    {
        $sql = 'SELECT c.* FROM `' . _DB_PREFIX_ . 'customer` c
                JOIN `' . _DB_PREFIX_ . 'customer_segment_customer` sc 
                ON c.id_customer = sc.id_customer
                WHERE sc.id_segment = ' . (int)$this->id;
                
        if ($limit > 0) {
            $sql .= ' LIMIT ' . (int)$offset . ', ' . (int)$limit;
        }
        
        return Db::getInstance()->executeS($sql);
    }
    
    // 세그먼트 규칙 가져오기
    public function getRules()
    {
        return Db::getInstance()->executeS(
            'SELECT * FROM `' . _DB_PREFIX_ . 'customer_segment_rule`
            WHERE `id_segment` = ' . (int)$this->id . '
            ORDER BY `id_segment_rule` ASC'
        );
    }
    
    // 세그먼트 규칙 추가
    public function addRule($rule_type, $rule_field, $rule_operator, $rule_value)
    {
        return Db::getInstance()->insert(
            'customer_segment_rule',
            [
                'id_segment' => (int)$this->id,
                'rule_type' => pSQL($rule_type),
                'rule_field' => pSQL($rule_field),
                'rule_operator' => pSQL($rule_operator),
                'rule_value' => pSQL($rule_value),
                'date_add' => date('Y-m-d H:i:s'),
                'date_upd' => date('Y-m-d H:i:s'),
            ]
        );
    }
    
    // 세그먼트 규칙 삭제
    public function deleteRule($id_rule)
    {
        return Db::getInstance()->delete(
            'customer_segment_rule',
            'id_segment_rule = ' . (int)$id_rule . ' AND id_segment = ' . (int)$this->id
        );
    }
    
    // 세그먼트 고객 업데이트 (규칙에 맞는 고객들 추가)
    public function updateCustomers()
    {
        // 기존 고객 관계 삭제
        Db::getInstance()->delete(
            'customer_segment_customer',
            'id_segment = ' . (int)$this->id
        );
        
        // 규칙에 맞는 고객 찾기
        $customers = $this->findMatchingCustomers();
        
        // 새 고객 관계 추가
        foreach ($customers as $id_customer) {
            Db::getInstance()->insert(
                'customer_segment_customer',
                [
                    'id_segment' => (int)$this->id,
                    'id_customer' => (int)$id_customer,
                    'date_add' => date('Y-m-d H:i:s'),
                ]
            );
        }
        
        return true;
    }
    
    // 규칙에 맞는 고객 찾기
    protected function findMatchingCustomers()
    {
        $rules = $this->getRules();
        if (empty($rules)) {
            return [];
        }
        
        // 규칙 기반 SQL 쿼리 생성
        $sql = 'SELECT DISTINCT c.id_customer FROM `' . _DB_PREFIX_ . 'customer` c ';
        
        // 규칙 타입에 따른 조인 및 조건 추가
        $where_conditions = [];
        $joins = [];
        
        foreach ($rules as $rule) {
            switch ($rule['rule_type']) {
                case 'customer':
                    $this->addCustomerRuleCondition($rule, $where_conditions);
                    break;
                    
                case 'order':
                    if (!in_array('order', $joins)) {
                        $joins['order'] = 'LEFT JOIN `' . _DB_PREFIX_ . 'orders` o ON o.id_customer = c.id_customer';
                    }
                    $this->addOrderRuleCondition($rule, $where_conditions);
                    break;
                    
                case 'product':
                    if (!in_array('order_detail', $joins)) {
                        $joins['order'] = 'LEFT JOIN `' . _DB_PREFIX_ . 'orders` o ON o.id_customer = c.id_customer';
                        $joins['order_detail'] = 'LEFT JOIN `' . _DB_PREFIX_ . 'order_detail` od ON od.id_order = o.id_order';
                    }
                    $this->addProductRuleCondition($rule, $where_conditions);
                    break;
                    
                case 'behavior':
                    if (!in_array('behavior', $joins)) {
                        $joins['behavior'] = 'LEFT JOIN `' . _DB_PREFIX_ . 'customer_behavior_log` bl ON bl.id_customer = c.id_customer';
                    }
                    $this->addBehaviorRuleCondition($rule, $where_conditions);
                    break;
            }
        }
        
        // 조인 추가
        foreach ($joins as $join) {
            $sql .= $join . ' ';
        }
        
        // WHERE 조건 추가
        if (!empty($where_conditions)) {
            $sql .= 'WHERE ' . implode(' AND ', $where_conditions) . ' ';
        }
        
        // 활성 고객만 포함
        $sql .= 'AND c.active = 1 AND c.deleted = 0';
        
        return Db::getInstance()->executeS($sql);
    }
    
    // 각 규칙 타입별 조건 추가 메소드들...
    protected function addCustomerRuleCondition($rule, &$where_conditions)
    {
        // 고객 속성 기반 조건
        $field = pSQL($rule['rule_field']);
        $operator = $this->getSqlOperator($rule['rule_operator']);
        $value = pSQL($rule['rule_value']);
        
        $where_conditions[] = "c.`{$field}` {$operator} '{$value}'";
    }
    
    protected function addOrderRuleCondition($rule, &$where_conditions)
    {
        // 주문 기반 조건
        // ...
    }
    
    protected function addProductRuleCondition($rule, &$where_conditions)
    {
        // 제품 구매 기반 조건
        // ...
    }
    
    protected function addBehaviorRuleCondition($rule, &$where_conditions)
    {
        // 행동 기반 조건
        // ...
    }
    
    // SQL 연산자 변환
    protected function getSqlOperator($operator)
    {
        switch ($operator) {
            case 'eq': return '=';
            case 'neq': return '!=';
            case 'gt': return '>';
            case 'gte': return '>=';
            case 'lt': return '<';
            case 'lte': return '<=';
            case 'contains': return 'LIKE';
            case 'not_contains': return 'NOT LIKE';
            case 'starts_with': return 'LIKE';
            case 'ends_with': return 'LIKE';
            default: return '=';
        }
    }
}

<?php
if (!defined('_PS_VERSION_')) {
    exit;
}

class AdminCustomerSegmentationController extends ModuleAdminController
{
    public function __construct()
    {
        $this->bootstrap = true;
        $this->table = 'customer_segment';
        $this->className = 'Segment';
        $this->lang = false;
        $this->addRowAction('edit');
        $this->addRowAction('delete');
        $this->addRowAction('view');
        $this->bulk_actions = [
            'delete' => [
                'text' => $this->l('Delete selected'),
                'confirm' => $this->l('Delete selected items?'),
                'icon' => 'icon-trash'
            ]
        ];
        
        $this->fields_list = [
            'id_segment' => [
                'title' => $this->l('ID'),
                'align' => 'center',
                'width' => 30
            ],
            'name' => [
                'title' => $this->l('Name'),
                'width' => 'auto'
            ],
            'description' => [
                'title' => $this->l('Description'),
                'width' => 'auto',
                'callback' => 'getDescriptionShort'
            ],
            'customer_count' => [
                'title' => $this->l('Customers'),
                'width' => 50,
                'align' => 'center',
                'callback' => 'getCustomerCount',
                'search' => false
            ],
            'active' => [
                'title' => $this->l('Active'),
                'width' => 50,
                'align' => 'center',
                'active' => 'status',
                'type' => 'bool',
                'orderby' => false
            ],
            'date_add' => [
                'title' => $this->l('Created'),
                'width' => 150,
                'type' => 'datetime'
            ]
        ];
        
        parent::__construct();
    }
    
    // 고객 수 표시 콜백
    public function getCustomerCount($count, $row)
    {
        $segment = new Segment($row['id_segment']);
        return $segment->getCustomerCount();
    }
    
    // 설명 짧게 표시 콜백
    public function getDescriptionShort($description, $row)
    {
        if (strlen($description) > 100) {
            return substr(strip_tags($description), 0, 100) . '...';
        }
        return strip_tags($description);
    }
    
    // 세그먼트 폼 렌더링
    public function renderForm()
    {
        $this->fields_form = [
            'legend' => [
                'title' => $this->l('Customer Segment'),
                'icon' => 'icon-group'
            ],
            'input' => [
                [
                    'type' => 'text',
                    'label' => $this->l('Name'),
                    'name' => 'name',
                    'required' => true
                ],
                [
                    'type' => 'textarea',
                    'label' => $this->l('Description'),
                    'name' => 'description',
                    'autoload_rte' => true,
                    'rows' => 5
                ],
                [
                    'type' => 'switch',
                    'label' => $this->l('Active'),
                    'name' => 'active',
                    'is_bool' => true,
                    'values' => [
                        [
                            'id' => 'active_on',
                            'value' => 1,
                            'label' => $this->l('Yes')
                        ],
                        [
                            'id' => 'active_off',
                            'value' => 0,
                            'label' => $this->l('No')
                        ]
                    ]
                ]
            ],
            'submit' => [
                'title' => $this->l('Save')
            ]
        ];
        
        // 세그먼트 규칙 관리 탭 추가
        if (Tools::isSubmit('updatecustomer_segment') && $id_segment = Tools::getValue('id_segment')) {
            $this->tabs = [
                'Segment' => $this->l('Segment'),
                'Rules' => $this->l('Rules'),
                'Customers' => $this->l('Customers')
            ];
        }
        
        return parent::renderForm();
    }
    
    // 규칙 관리 탭 렌더링
    public function renderRulesTab()
    {
        $id_segment = (int)Tools::getValue('id_segment');
        $segment = new Segment($id_segment);
        
        // 규칙 추가 폼
        $rule_types = [
            'customer' => $this->l('Customer Attributes'),
            'order' => $this->l('Order History'),
            'product' => $this->l('Product Purchases'),
            'behavior' => $this->l('Customer Behavior')
        ];
        
        // 규칙 필드 (타입별로 다른 필드 제공)
        $rule_fields = [
            'customer' => [
                'id_gender' => $this->l('Gender'),
                'birthday' => $this->l('Birthday'),
                'newsletter' => $this->l('Newsletter'),
                'optin' => $this->l('Opt-in'),
                'date_add' => $this->l('Registration Date')
            ],
            'order' => [
                'total_orders' => $this->l('Total Orders'),
                'total_spent' => $this->l('Total Spent'),
                'average_cart' => $this->l('Average Cart Value'),
                'last_order_date' => $this->l('Last Order Date')
            ],
            // 다른 타입의 필드들...
        ];
        
        // 연산자
        $operators = [
            'eq' => $this->l('Equals'),
            'neq' => $this->l('Not Equals'),
            'gt' => $this->l('Greater Than'),
            'gte' => $this->l('Greater Than or Equal'),
            'lt' => $this->l('Less Than'),
            'lte' => $this->l('Less Than or Equal'),
            'contains' => $this->l('Contains'),
            'not_contains' => $this->l('Does Not Contain'),
            'starts_with' => $this->l('Starts With'),
            'ends_with' => $this->l('Ends With')
        ];
        
        // 현재 규칙 목록
        $rules = $segment->getRules();
        
        // 템플릿에 변수 할당
        $this->context->smarty->assign([
            'id_segment' => $id_segment,
            'rule_types' => $rule_types,
            'rule_fields' => json_encode($rule_fields),
            'operators' => $operators,
            'rules' => $rules
        ]);
        
        return $this->context->smarty->fetch(_PS_MODULE_DIR_ . 'customer_segmentation/views/templates/admin/rules_tab.tpl');
    }
    
    // 고객 목록 탭 렌더링
    public function renderCustomersTab()
    {
        $id_segment = (int)Tools::getValue('id_segment');
        $segment = new Segment($id_segment);
        
        // 페이지네이션
        $page = (int)Tools::getValue('page', 1);
        $limit = 50;
        $offset = ($page - 1) * $limit;
        
        // 고객 목록 가져오기
        $customers = $segment->getCustomers($limit, $offset);
        $total_customers = $segment->getCustomerCount();
        
        // 페이지네이션 링크
        $pagination = [];
        $total_pages = ceil($total_customers / $limit);
        for ($i = 1; $i <= $total_pages; $i++) {
            $pagination[] = [
                'page' => $i,
                'current' => ($i == $page)
            ];
        }
        
        // 템플릿에 변수 할당
        $this->context->smarty->assign([
            'customers' => $customers,
            'total_customers' => $total_customers,
            'pagination' => $pagination,
            'current_page' => $page
        ]);
        
        return $this->context->smarty->fetch(_PS_MODULE_DIR_ . 'customer_segmentation/views/templates/admin/customers_tab.tpl');
    }
    
    // 세그먼트 저장 후 처리
    public function postProcess()
    {
        // 규칙 추가
        if (Tools::isSubmit('add_rule') && $id_segment = Tools::getValue('id_segment')) {
            $segment = new Segment($id_segment);
            $rule_type = Tools::getValue('rule_type');
            $rule_field = Tools::getValue('rule_field');
            $rule_operator = Tools::getValue('rule_operator');
            $rule_value = Tools::getValue('rule_value');
            
            if ($segment->addRule($rule_type, $rule_field, $rule_operator, $rule_value)) {
                $this->confirmations[] = $this->l('Rule added successfully.');
            } else {
                $this->errors[] = $this->l('Error adding rule.');
            }
            
            // 세그먼트 고객 업데이트
            $segment->updateCustomers();
        }
        
        // 규칙 삭제
        if (Tools::isSubmit('delete_rule') && $id_rule = Tools::getValue('id_rule') && $id_segment = Tools::getValue('id_segment')) {
            $segment = new Segment($id_segment);
            
            if ($segment->deleteRule($id_rule)) {
                $this->confirmations[] = $this->l('Rule deleted successfully.');
            } else {
                $this->errors[] = $this->l('Error deleting rule.');
            }
            
            // 세그먼트 고객 업데이트
            $segment->updateCustomers();
        }
        
        // 세그먼트 저장 후 고객 업데이트
        if (Tools::isSubmit('submitAddcustomer_segment') || Tools::isSubmit('submitAddcustomer_segmentAndStay')) {
            $result = parent::postProcess();
            
            if (!count($this->errors) && $id_segment = Tools::getValue('id_segment')) {
                $segment = new Segment($id_segment);
                $segment->updateCustomers();
            }
            
            return $result;
        }
        
        return parent::postProcess();
    }
}

{* 규칙 관리 탭 템플릿 *}
<div class="panel">
    <div class="panel-heading">
        <i class="icon-filter"></i> {l s='Segment Rules' mod='customer_segmentation'}
    </div>
    
    {* 현재 규칙 목록 *}
    <div class="table-responsive">
        <table class="table">
            <thead>
                <tr>
                    <th>{l s='Type' mod='customer_segmentation'}</th>
                    <th>{l s='Field' mod='customer_segmentation'}</th>
                    <th>{l s='Operator' mod='customer_segmentation'}</th>
                    <th>{l s='Value' mod='customer_segmentation'}</th>
                    <th>{l s='Actions' mod='customer_segmentation'}</th>
                </tr>
            </thead>
            <tbody>
                {if $rules|count > 0}
                    {foreach from=$rules item=rule}
                        <tr>
                            <td>{$rule_types[$rule.rule_type]}</td>
                            <td>{$rule.rule_field}</td>
                            <td>{$operators[$rule.rule_operator]}</td>
                            <td>{$rule.rule_value}</td>
                            <td>
                                <a href="{$current|escape:'html':'UTF-8'}&{$identifier}={$id_segment}&delete_rule=1&id_rule={$rule.id_segment_rule}&token={$token|escape:'html':'UTF-8'}" 
                                   class="btn btn-default" 
                                   onclick="return confirm('{l s='Are you sure?' mod='customer_segmentation'}');">
                                    <i class="icon-trash"></i> {l s='Delete' mod='customer_segmentation'}
                                </a>
                            </td>
                        </tr>
                    {/foreach}
                {else}
                    <tr>
                        <td colspan="5" class="text-center">{l s='No rules defined yet.' mod='customer_segmentation'}</td>
                    </tr>
                {/if}
            </tbody>
        </table>
    </div>
    
    {* 규칙 추가 폼 *}
    <form id="add_rule_form" class="form-horizontal" action="{$current|escape:'html':'UTF-8'}&{$identifier}={$id_segment}&token={$token|escape:'html':'UTF-8'}" method="post">
        <div class="form-group">
            <label class="control-label col-lg-3">{l s='Rule Type' mod='customer_segmentation'}</label>
            <div class="col-lg-9">
                <select name="rule_type" id="rule_type" class="form-control">
                    {foreach from=$rule_types key=type item=label}
                        <option value="{$type}">{$label}</option>
                    {/foreach}
                </select>
            </div>
        </div>
        
        <div class="form-group">
            <label class="control-label col-lg-3">{l s='Field' mod='customer_segmentation'}</label>
            <div class="col-lg-9">
                <select name="rule_field" id="rule_field" class="form-control">
                    {* JavaScript로 동적 업데이트 *}
                </select>
            </div>
        </div>
        
        <div class="form-group">
            <label class="control-label col-lg-3">{l s='Operator' mod='customer_segmentation'}</label>
            <div class="col-lg-9">
                <select name="rule_operator" id="rule_operator" class="form-control">
                    {foreach from=$operators key=op item=label}
                        <option value="{$op}">{$label}</option>
                    {/foreach}
                </select>
            </div>
        </div>
        
        <div class="form-group">
            <label class="control-label col-lg-3">{l s='Value' mod='customer_segmentation'}</label>
            <div class="col-lg-9">
                <input type="text" name="rule_value" class="form-control" required>
            </div>
        </div>
        
        <div class="panel-footer">
            <input type="hidden" name="add_rule" value="1">
            <button type="submit" class="btn btn-default pull-right">
                <i class="process-icon-save"></i> {l s='Add Rule' mod='customer_segmentation'}
            </button>
        </div>
    </form>
</div>

{* 필드 동적 업데이트를 위한 JavaScript *}
<script type="text/javascript">
    var rule_fields = {$rule_fields};
    
    $(document).ready(function() {
        // 규칙 타입 변경 시 필드 목록 업데이트
        $('#rule_type').change(function() {
            updateRuleFields();
        });
        
        // 초기 필드 목록 설정
        updateRuleFields();
        
        function updateRuleFields() {
            var type = $('#rule_type').val();
            var fields = rule_fields[type];
            var $field_select = $('#rule_field');
            
            $field_select.empty();
            
            $.each(fields, function(value, label) {
                $field_select.append($('<option></option>').attr('value', value).text(label));
            });
        }
    });
</script>

<?php
if (!defined('_PS_VERSION_')) {
    exit;
}

class SegmentEmail
{
    // 세그먼트에 속한 고객들에게 이메일 발송
    public static function sendEmailToSegment($id_segment, $subject, $template, $template_vars = [])
    {
        $segment = new Segment($id_segment);
        $customers = $segment->getCustomers();
        $success_count = 0;
        $error_count = 0;
        
        foreach ($customers as $customer) {
            $customer_obj = new Customer($customer['id_customer']);
            
            // 고객별 템플릿 변수 설정
            $customer_vars = $template_vars;
            $customer_vars['{firstname}'] = $customer_obj->firstname;
            $customer_vars['{lastname}'] = $customer_obj->lastname;
            $customer_vars['{email}'] = $customer_obj->email;
            
            // 이메일 발송
            $result = Mail::send(
                (int)Context::getContext()->language->id,
                $template,
                $subject,
                $customer_vars,
                $customer_obj->email,
                $customer_obj->firstname . ' ' . $customer_obj->lastname,
                null,
                null,
                null,
                null,
                _PS_MODULE_DIR_ . 'customer_segmentation/mails/'
            );
            
            if ($result) {
                $success_count++;
            } else {
                $error_count++;
            }
        }
        
        return [
            'success' => $success_count,
            'error' => $error_count,
            'total' => count($customers)
        ];
    }
    
    // 이메일 템플릿 목록 가져오기
    public static function getEmailTemplates()
    {
        $templates = [];
        $dir = _PS_MODULE_DIR_ . 'customer_segmentation/mails/templates/';
        
        if (is_dir($dir)) {
            $files = scandir($dir);
            foreach ($files as $file) {
                if (substr($file, -4) == '.tpl') {
                    $template_name = substr($file, 0, -4);
                    $templates[$template_name] = $template_name;
                }
            }
        }
        
        return $templates;
    }
    
    // 이메일 발송 기록 저장
    public static function logEmailCampaign($id_segment, $subject, $template, $results)
    {
        return Db::getInstance()->insert(
            'customer_segment_email_log',
            [
                'id_segment' => (int)$id_segment,
                'subject' => pSQL($subject),
                'template' => pSQL($template),
                'sent_count' => (int)$results['success'],
                'error_count' => (int)$results['error'],
                'date_add' => date('Y-m-d H:i:s')
            ]
        );
    }
}

<?php
if (!defined('_PS_VERSION_')) {
    exit;
}

require_once _PS_MODULE_DIR_ . 'customer_segmentation/classes/SegmentEmail.php';

class AdminSegmentEmailController extends ModuleAdminController
{
    public function __construct()
    {
        $this->bootstrap = true;
        $this->table = 'customer_segment_email_log';
        $this->className = 'SegmentEmailLog';
        $this->lang = false;
        
        // 이메일 로그 목록 필드
        $this->fields_list = [
            'id_email_log' => [
                'title' => $this->l('ID'),
                'align' => 'center',
                'width' => 30
            ],
            'id_segment' => [
                'title' => $this->l('Segment'),
                'width' => 'auto',
                'callback' => 'getSegmentName'
            ],
            'subject' => [
                'title' => $this->l('Subject'),
                'width' => 'auto'
            ],
            'template' => [
                'title' => $this->l('Template'),
                'width' => 'auto'
            ],
            'sent_count' => [
                'title' => $this->l('Sent'),
                'width' => 50,
                'align' => 'center'
            ],
            'error_count' => [
                'title' => $this->l('Errors'),
                'width' => 50,
                'align' => 'center'
            ],
            'date_add' => [
                'title' => $this->l('Date'),
                'width' => 150,
                'type' => 'datetime'
            ]
        ];
        
        parent::__construct();
    }
    
    // 세그먼트 이름 표시 콜백
    public function getSegmentName($id_segment)
    {
        $segment = new Segment($id_segment);
        return $segment->name;
    }
    
    // 이메일 발송 폼 렌더링
    public function renderForm()
    {
        // 세그먼트 목록 가져오기
        $segments = Segment::getSegments(true);
        $segment_options = [];
        
        foreach ($segments as $segment) {
            $segment_options[] = [
                'id_segment' => $segment['id_segment'],
                'name' => $segment['name'] . ' (' . $segment['customer_count'] . ' customers)'
            ];
        }
        
        // 이메일 템플릿 목록
        $templates = SegmentEmail::getEmailTemplates();
        $template_options = [];
        
        foreach ($templates as $key => $name) {
            $template_options[] = [
                'id_template' => $key,
                'name' => $name
            ];
        }
        
        // 폼 필드 정의
        $this->fields_form = [
            'legend' => [
                'title' => $this->l('Send Email to Segment'),
                'icon' => 'icon-envelope'
            ],
            'input' => [
                [
                    'type' => 'select',
                    'label' => $this->l('Segment'),
                    'name' => 'id_segment',
                    'required' => true,
                    'options' => [
                        'query' => $segment_options,
                        'id' => 'id_segment',
                        'name' => 'name'
                    ]
                ],
                [
                    'type' => 'text',
                    'label' => $this->l('Subject'),
                    'name' => 'subject',
                    'required' => true
                ],
                [
                    'type' => 'select',
                    'label' => $this->l('Template'),
                    'name' => 'template',
                    'required' => true,
                    'options' => [
                        'query' => $template_options,
                        'id' => 'id_template',
                        'name' => 'name'
                    ]
                ],
                [
                    'type' => 'textarea',
                    'label' => $this->l('Additional Content'),
                    'name' => 'content',
                    'autoload_rte' => true,
                    'rows' => 5,
                    'desc' => $this->l('This content will be available in the template as {content}')
                ]
            ],
            'submit' => [
                'title' => $this->l('Send Email')
            ]
        ];
        
        return parent::renderForm();
    }
    
    // 이메일 발송 처리
    public function postProcess()
    {
        if (Tools::isSubmit('submitAdd' . $this->table)) {
            $id_segment = (int)Tools::getValue('id_segment');
            $subject = Tools::getValue('subject');
            $template = Tools::getValue('template');
            $content = Tools::getValue('content');
            
            // 필수 필드 검증
            if (!$id_segment || empty($subject) || empty($template)) {
                $this->errors[] = $this->l('All fields are required.');
                return false;
            }
            
            // 템플릿 변수 설정
            $template_vars = [
                '{content}' => $content,
                '{shop_name}' => Configuration::get('PS_SHOP_NAME'),
                '{shop_url}' => Context::getContext()->link->getPageLink('index')
            ];
            
            // 이메일 발송
            $results = SegmentEmail::sendEmailToSegment($id_segment, $subject, $template, $template_vars);
            
            // 결과 로깅
            SegmentEmail::logEmailCampaign($id_segment, $subject, $template, $results);
            
            // 결과 메시지
            $this->confirmations[] = sprintf(
                $this->l('Email sent to %d customers (%d errors).'),
                $results['success'],
                $results['error']
            );
            
            // 목록 페이지로 리다이렉트
            Tools::redirectAdmin(self::$currentIndex . '&token=' . $this->token);
        }
        
        return parent::postProcess();
    }
}

<?php
if (!defined('_PS_VERSION_')) {
    exit;
}

class SegmentCoupon
{
    // 세그먼트에 속한 고객들에게 쿠폰 생성
    public static function createCouponsForSegment($id_segment, $name, $discount_type, $discount_value, $minimum_amount, $validity_days)
    {
        $segment = new Segment($id_segment);
        $customers = $segment->getCustomers();
        $success_count = 0;
        
        // 카트 규칙 생성 (쿠폰 템플릿)
        $cart_rule = new CartRule();
        $cart_rule->name = [];
        
        foreach (Language::getLanguages(true) as $lang) {
            $cart_rule->name[$lang['id_lang']] = $name;
        }
        
        $cart_rule->description = 'Generated for segment: ' . $segment->name;
        $cart_rule->code = 'SEG' . $id_segment . '_' . strtoupper(Tools::passwdGen(8));
        $cart_rule->quantity = 1;
        $cart_rule->quantity_per_user = 1;
        
        // 할인 설정
        if ($discount_type == 'percent') {
            $cart_rule->reduction_percent = (float)$discount_value;
        } else {
            $cart_rule->reduction_amount = (float)$discount_value;
            $cart_rule->reduction_tax = true;
        }
        
        // 최소 주문 금액
        if ($minimum_amount > 0) {
            $cart_rule->minimum_amount = (float)$minimum_amount;
            $cart_rule->minimum_amount_tax = true;
            $cart_rule->minimum_amount_currency = (int)Configuration::get('PS_CURRENCY_DEFAULT');
            $cart_rule->minimum_amount_shipping = false;
        }
        
        // 유효 기간
        $now = new DateTime();
        $cart_rule->date_from = $now->format('Y-m-d H:i:s');
        $now->add(new DateInterval('P' . (int)$validity_days . 'D'));
        $cart_rule->date_to = $now->format('Y-m-d H:i:s');
        
        $cart_rule->active = 1;
        
        // 쿠폰 템플릿 저장
        if (!$cart_rule->add()) {
            return [
                'success' => 0,
                'error' => count($customers),
                'total' => count($customers)
            ];
        }
        
        // 각 고객별 개인화된 쿠폰 생성
        foreach ($customers as $customer) {
            $customer_rule = new CartRule((int)$cart_rule->id);
            $customer_rule->id = 0; // 새 객체로 설정
            $customer_rule->code = 'SEG' . $id_segment . '_CUST' . $customer['id_customer'] . '_' . strtoupper(Tools::passwdGen(6));
            $customer_rule->id_customer = (int)$customer['id_customer'];
            
            if ($customer_rule->add()) {
                $success_count++;
                
                // 쿠폰 생성 알림 이메일 발송 (선택적)
                self::sendCouponEmail($customer_rule, new Customer($customer['id_customer']));
            }
        }
        
        return [
            'success' => $success_count,
            'error' => count($customers) - $success_count,
            'total' => count($customers)
        ];
    }
    
    // 쿠폰 생성 알림 이메일 발송
    protected static function sendCouponEmail($cart_rule, $customer)
    {
        $template_vars = [
            '{firstname}' => $customer->firstname,
            '{lastname}' => $customer->lastname,
            '{coupon_code}' => $cart_rule->code,
            '{coupon_name}' => $cart_rule->name[(int)Context::getContext()->language->id],
            '{coupon_description}' => $cart_rule->description,
            '{coupon_validity}' => Tools::displayDate($cart_rule->date_to)
        ];
        
        return Mail::send(
            (int)Context::getContext()->language->id,
            'coupon',
            sprintf(Context::getContext()->getTranslator()->trans('Your coupon code: %s', [], 'Emails.Subject'), $cart_rule->code),
            $template_vars,
            $customer->email,
            $customer->firstname . ' ' . $customer->lastname,
            null,
            null,
            null,
            null,
            _PS_MODULE_DIR_ . 'customer_segmentation/mails/'
        );
    }
    
    // 쿠폰 생성 기록 저장
    public static function logCouponCampaign($id_segment, $name, $discount_type, $discount_value, $results)
    {
        return Db::getInstance()->insert(
            'customer_segment_coupon_log',
            [
                'id_segment' => (int)$id_segment,
                'name' => pSQL($name),
                'discount_type' => pSQL($discount_type),
                'discount_value' => (float)$discount_value,
                'created_count' => (int)$results['success'],
                'error_count' => (int)$results['error'],
                'date_add' => date('Y-m-d H:i:s')
            ]
        );
    }
}

// 고객 행동 로그 테이블에 인덱스 추가
$sql[] = 'ALTER TABLE `' . _DB_PREFIX_ . 'customer_behavior_log` 
          ADD INDEX `idx_customer_action_date` (`id_customer`, `action_type`, `date_add`),
          ADD INDEX `idx_action_reference` (`action_type`, `id_reference`);';

// 세그먼트 규칙 테이블에 인덱스 추가
$sql[] = 'ALTER TABLE `' . _DB_PREFIX_ . 'customer_segment_rule` 
          ADD INDEX `idx_rule_type_field` (`rule_type`, `rule_field`);';

// 세그먼트-고객 관계 테이블에 인덱스 추가
$sql[] = 'ALTER TABLE `' . _DB_PREFIX_ . 'customer_segment_customer` 
          ADD INDEX `idx_customer` (`id_customer`);';

// Segment 클래스의 updateCustomers 메소드 수정
public function updateCustomers($batch_size = 1000)
{
    // 기존 고객 관계 삭제
    Db::getInstance()->delete(
        'customer_segment_customer',
        'id_segment = ' . (int)$this->id
    );
    
    // 규칙에 맞는 고객 찾기 (배치 처리)
    $offset = 0;
    $total_inserted = 0;
    
    while (true) {
        $customers = $this->findMatchingCustomers($batch_size, $offset);
        
        if (empty($customers)) {
            break;
        }
        
        // 배치 삽입 준비
        $values = [];
        foreach ($customers as $customer) {
            $values[] = '(' . (int)$this->id . ', ' . (int)$customer['id_customer'] . ', "' . pSQL(date('Y-m-d H:i:s')) . '")';
        }
        
        // 배치 삽입 실행
        if (!empty($values)) {
            $sql = 'INSERT INTO `' . _DB_PREFIX_ . 'customer_segment_customer` 
                   (id_segment, id_customer, date_add) 
                   VALUES ' . implode(', ', $values);
            
            Db::getInstance()->execute($sql);
            $total_inserted += count($values);
        }
        
        $offset += $batch_size;
    }
    
    return $total_inserted;
}

// findMatchingCustomers 메소드도 수정
protected function findMatchingCustomers($limit = 1000, $offset = 0)
{
    // 기존 코드...
    
    // LIMIT 추가
    $sql .= ' LIMIT ' . (int)$offset . ', ' . (int)$limit;
    
    return Db::getInstance()->executeS($sql);
}

// Segment 클래스에 캐싱 기능 추가
public function getCustomerCount()
{
    // 캐시 키 생성
    $cache_key = 'segment_customer_count_' . (int)$this->id;
    
    // 캐시에서 데이터 확인
    if (Cache::isStored($cache_key)) {
        return Cache::retrieve($cache_key);
    }
    
    // 캐시에 없으면 DB에서 조회
    $count = Db::getInstance()->getValue(
        'SELECT COUNT(*) FROM `' . _DB_PREFIX_ . 'customer_segment_customer`
        WHERE `id_segment` = ' . (int)$this->id
    );
    
    // 캐시에 저장 (1시간 유효)
    Cache::store($cache_key, $count, 3600);
    
    return $count;
}

// 캐시 무효화 메소드 추가
public function clearCache()
{
    $cache_key = 'segment_customer_count_' . (int)$this->id;
    Cache::delete($cache_key);
    
    // 다른 캐시 키들도 필요에 따라 삭제
}

// 비동기 작업 클래스 생성 (classes/SegmentTask.php)
class SegmentTask
{
    public static function scheduleSegmentUpdate($id_segment)
    {
        // 작업 큐에 추가
        return Db::getInstance()->insert(
            'customer_segment_task',
            [
                'task_type' => 'update_segment',
                'id_reference' => (int)$id_segment,
                'status' => 'pending',
                'date_add' => date('Y-m-d H:i:s')
            ]
        );
    }
    
    public static function processTasks($limit = 5)
    {
        // 대기 중인 작업 가져오기
        $tasks = Db::getInstance()->executeS(
            'SELECT * FROM `' . _DB_PREFIX_ . 'customer_segment_task`
            WHERE `status` = "pending"
            ORDER BY `date_add` ASC
            LIMIT ' . (int)$limit
        );
        
        foreach ($tasks as $task) {
            // 작업 상태 업데이트
            Db::getInstance()->update(
                'customer_segment_task',
                ['status' => 'processing', 'date_upd' => date('Y-m-d H:i:s')],
                'id_task = ' . (int)$task['id_task']
            );
            
            try {
                // 작업 유형에 따른 처리
                switch ($task['task_type']) {
                    case 'update_segment':
                        $segment = new Segment((int)$task['id_reference']);
                        $segment->updateCustomers();
                        break;
                    
                    // 다른 작업 유형들...
                }
                
                // 작업 완료 처리
                Db::getInstance()->update(
                    'customer_segment_task',
                    ['status' => 'completed', 'date_upd' => date('Y-m-d H:i:s')],
                    'id_task = ' . (int)$task['id_task']
                );
            } catch (Exception $e) {
                // 오류 처리
                Db::getInstance()->update(
                    'customer_segment_task',
                    [
                        'status' => 'error',
                        'error_message' => pSQL($e->getMessage()),
                        'date_upd' => date('Y-m-d H:i:s')
                    ],
                    'id_task = ' . (int)$task['id_task']
                );
            }
        }
        
        return count($tasks);
    }
}

// 작업 처리를 위한 크론 작업 추가
public function hookActionCronJob($params)
{
    require_once _PS_MODULE_DIR_ . 'customer_segmentation/classes/SegmentTask.php';
    return SegmentTask::processTasks();
}

// AdminCustomerSegmentationController 클래스에 권한 체크 추가
public function __construct()
{
    // 기존 코드...
    
    // 권한 설정
    $this->addRowActionSkipList('delete', [1]); // ID가 1인 기본 세그먼트는 삭제 불가
    $this->addRowActionSkipList('edit', [1]);   // ID가 1인 기본 세그먼트는 수정 불가
    
    // 권한 확인
    if (!$this->checkAccess()) {
        $this->errors[] = $this->l('You do not have permission to view this page.');
        return;
    }
    
    parent::__construct();
}

// 액션 실행 전 권한 체크
public function postProcess()
{
    if ($this->action) {
        // 특정 액션에 대한 권한 체크
        switch ($this->action) {
            case 'delete':
                if (!$this->tabAccess['delete']) {
                    $this->errors[] = $this->l('You do not have permission to delete segments.');
                    return false;
                }
                break;
                
            case 'edit':
            case 'update':
                if (!$this->tabAccess['edit']) {
                    $this->errors[] = $this->l('You do not have permission to edit segments.');
                    return false;
                }
                break;
                
            case 'create':
            case 'add':
                if (!$this->tabAccess['add']) {
                    $this->errors[] = $this->l('You do not have permission to add segments.');
                    return false;
                }
                break;
        }
    }
    
    return parent::postProcess();
}

// 세그먼트 규칙 추가 시 입력 검증
public function postProcess()
{
    if (Tools::isSubmit('add_rule') && $id_segment = Tools::getValue('id_segment')) {
        // 입력 검증
        $rule_type = Tools::getValue('rule_type');
        $rule_field = Tools::getValue('rule_field');
        $rule_operator = Tools::getValue('rule_operator');
        $rule_value = Tools::getValue('rule_value');
        
        // 유효한 규칙 타입인지 확인
        $valid_types = ['customer', 'order', 'product', 'behavior'];
        if (!in_array($rule_type, $valid_types)) {
            $this->errors[] = $this->l('Invalid rule type.');
            return false;
        }
        
        // 필드명 검증 (알파벳, 숫자, 언더스코어만 허용)
        if (!preg_match('/^[a-zA-Z0-9_]+$/', $rule_field)) {
            $this->errors[] = $this->l('Invalid field name.');
            return false;
        }
        
        // 연산자 검증
        $valid_operators = ['eq', 'neq', 'gt', 'gte', 'lt', 'lte', 'contains', 'not_contains', 'starts_with', 'ends_with'];
        if (!in_array($rule_operator, $valid_operators)) {
            $this->errors[] = $this->l('Invalid operator.');
            return false;
        }
        
        // 값 검증 (XSS 방지)
        $rule_value = Tools::purifyHTML($rule_value);
        
        // 검증 통과 후 처리
        $segment = new Segment($id_segment);
        // ...
    }
    
    // ...
}

// GDPR 관련 기능 추가 (classes/SegmentGDPR.php)
class SegmentGDPR
{
    // 고객 데이터 내보내기
    public static function exportCustomerData($id_customer)
    {
        $data = [];
        
        // 고객이 속한 세그먼트 목록
        $segments = Db::getInstance()->executeS(
            'SELECT s.* FROM `' . _DB_PREFIX_ . 'customer_segment` s
            JOIN `' . _DB_PREFIX_ . 'customer_segment_customer` sc ON s.id_segment = sc.id_segment
            WHERE sc.id_customer = ' . (int)$id_customer
        );
        
        $data['segments'] = [];
        foreach ($segments as $segment) {
            $data['segments'][] = [
                'name' => $segment['name'],
                'description' => $segment['description'],
                'date_added' => $segment['date_add']
            ];
        }
        
        // 고객 행동 로그
        $behaviors = Db::getInstance()->executeS(
            'SELECT * FROM `' . _DB_PREFIX_ . 'customer_behavior_log`
            WHERE `id_customer` = ' . (int)$id_customer . '
            ORDER BY `date_add` DESC'
        );
        
        $data['behaviors'] = [];
        foreach ($behaviors as $behavior) {
            $data['behaviors'][] = [
                'action_type' => $behavior['action_type'],
                'reference' => $behavior['id_reference'],
                'data' => $behavior['data'],
                'date' => $behavior['date_add']
            ];
        }
        
        return $data;
    }
    
    // 고객 데이터 삭제
    public static function deleteCustomerData($id_customer)
    {
        // 세그먼트-고객 관계 삭제
        Db::getInstance()->delete(
            'customer_segment_customer',
            'id_customer = ' . (int)$id_customer
        );
        
        // 행동 로그 익명화
        Db::getInstance()->update(
            'customer_behavior_log',
            [
                'id_customer' => 0,
                'data' => '[anonymized]'
            ],
            'id_customer = ' . (int)$id_customer
        );
        
        return true;
    }
}

// 모듈에 GDPR 훅 추가
public function hookActionDeleteGDPRCustomer($params)
{
    require_once _PS_MODULE_DIR_ . 'customer_segmentation/classes/SegmentGDPR.php';
    return SegmentGDPR::deleteCustomerData($params['id_customer']);
}

public function hookActionExportGDPRData($params)
{
    require_once _PS_MODULE_DIR_ . 'customer_segmentation/classes/SegmentGDPR.php';
    return SegmentGDPR::exportCustomerData($params['id_customer']);
}

// 데이터 암호화/복호화 유틸리티 (classes/SegmentCrypto.php)
class SegmentCrypto
{
    private static $key;
    
    // 암호화 키 초기화
    private static function initKey()
    {
        if (!isset(self::$key)) {
            // 프레스토샵의 보안 키 활용
            self::$key = _COOKIE_KEY_;
        }
    }
    
    // 데이터 암호화
    public static function encrypt($data)
    {
        self::initKey();
        
        // 암호화 방식 (OpenSSL 사용)
        $iv = openssl_random_pseudo_bytes(openssl_cipher_iv_length('aes-256-cbc'));
        $encrypted = openssl_encrypt($data, 'aes-256-cbc', self::$key, 0, $iv);
        
        // IV와 암호화된 데이터 합치기
        return base64_encode($iv . $encrypted);
    }
    
    // 데이터 복호화
    public static function decrypt($data)
    {
        self::initKey();
        
        $data = base64_decode($data);
        
        // IV 분리
        $iv_length = openssl_cipher_iv_length('aes-256-cbc');
        $iv = substr($data, 0, $iv_length);
        $encrypted = substr($data, $iv_length);
        
        // 복호화
        return openssl_decrypt($encrypted, 'aes-256-cbc', self::$key, 0, $iv);
    }
}

// tests/SegmentTest.php
class SegmentTest extends PHPUnit\Framework\TestCase
{
    protected $segment;
    
    protected function setUp(): void
    {
        // 테스트용 세그먼트 생성
        $this->segment = new Segment();
        $this->segment->name = 'Test Segment';
        $this->segment->description = 'Test Description';
        $this->segment->active = 1;
        $this->segment->add();
    }
    
    protected function tearDown(): void
    {
        // 테스트 후 정리
        if ($this->segment->id) {
            $this->segment->delete();
        }
    }
    
    public function testAddRule()
    {
        // 규칙 추가 테스트
        $result = $this->segment->addRule('customer', 'newsletter', 'eq', '1');
        $this->assertTrue($result);
        
        // 규칙이 제대로 추가되었는지 확인
        $rules = $this->segment->getRules();
        $this->assertCount(1, $rules);
        $this->assertEquals('customer', $rules[0]['rule_type']);
        $this->assertEquals('newsletter', $rules[0]['rule_field']);
        $this->assertEquals('eq', $rules[0]['rule_operator']);
        $this->assertEquals('1', $rules[0]['rule_value']);
    }
    
    public function testFindMatchingCustomers()
    {
        // 뉴스레터 구독 고객 세그먼트 규칙 추가
        $this->segment->addRule('customer', 'newsletter', 'eq', '1');
        
        // 테스트용 고객 생성
        $customer1 = new Customer();
        $customer1->firstname = 'Test';
        $customer1->lastname = 'User1';
        $customer1->email = 'test1@example.com';
        $customer1->passwd = Tools::hash('password');
        $customer1->newsletter = 1;
        $customer1->add();
        
        $customer2 = new Customer();
        $customer2->firstname = 'Test';
        $customer2->lastname = 'User2';
        $customer2->email = 'test2@example.com';
        $customer2->passwd = Tools::hash('password');
        $customer2->newsletter = 0;
        $customer2->add();
        
        // 세그먼트 업데이트
        $this->segment->updateCustomers();
        
        // 결과 확인
        $segment_customers = $this->segment->getCustomers();
        $this->assertCount(1, $segment_customers);
        $this->assertEquals($customer1->id, $segment_customers[0]['id_customer']);
        
        // 테스트 고객 삭제
        $customer1->delete();
        $customer2->delete();
    }
    
    // 다른 테스트 메소드들...
}

// tests/IntegrationTest.php
class IntegrationTest extends PHPUnit\Framework\TestCase
{
    protected $module;
    
    protected function setUp(): void
    {
        // 모듈 인스턴스 생성
        $this->module = Module::getInstanceByName('customer_segmentation');
    }
    
    public function testFullWorkflow()
    {
        // 1. 세그먼트 생성
        $segment = new Segment();
        $segment->name = 'Integration Test Segment';
        $segment->description = 'Testing full workflow';
        $segment->active = 1;
        $segment->add();
        
        // 2. 규칙 추가
        $segment->addRule('customer', 'id_gender', 'eq', '1'); // 남성 고객
        $segment->addRule('order', 'total_spent', 'gt', '100'); // 100 이상 구매 고객
        
        // 3. 세그먼트 업데이트
        $customer_count = $segment->updateCustomers();
        
        // 4. 이메일 발송 테스트
        if ($customer_count > 0) {
            $result = SegmentEmail::sendEmailToSegment(
                $segment->id,
                'Test Email',
                'test_template',
                ['{content}' => 'This is a test email']
            );
            
            $this->assertGreaterThan(0, $result['success']);
        }
        
        // 5. 쿠폰 생성 테스트
        $coupon_result = SegmentCoupon::createCouponsForSegment(
            $segment->id,
            'Test Coupon',
            'percent',
            10,
            0,
            30
        );
        
        // 정리
        $segment->delete();
    }
    
    // 다른 통합 테스트 메소드들...
}

// classes/SegmentDebug.php
class SegmentDebug
{
    private static $logs = [];
    private static $enabled = false;
    
    // 디버그 모드 활성화/비활성화
    public static function enable($enabled = true)
    {
        self::$enabled = $enabled;
    }
    
    // 로그 추가
    public static function log($message, $data = null)
    {
        if (!self::$enabled) {
            return;
        }
        
        self::$logs[] = [
            'time' => microtime(true),
            'message' => $message,
            'data' => $data
        ];
    }
    
    // SQL 쿼리 로깅
    public static function logQuery($sql, $params = [])
    {
        if (!self::$enabled) {
            return;
        }
        
        self::$logs[] = [
            'time' => microtime(true),
            'type' => 'sql',
            'query' => $sql,
            'params' => $params
        ];
    }
    
    // 로그 가져오기
    public static function getLogs()
    {
        return self::$logs;
    }
    
    // 로그 출력
    public static function display()
    {
        if (!self::$enabled || empty(self::$logs)) {
            return;
        }
        
        echo '<div class="segment-debug-panel" style="position:fixed; bottom:0; right:0; width:400px; height:300px; overflow:auto; background:#fff; border:1px solid #ccc; padding:10px; z-index:9999;">';
        echo '<h3>Segment Debug</h3>';
        
        foreach (self::$logs as $log) {
            echo '<div class="log-entry" style="margin-bottom:5px; border-bottom:1px solid #eee; padding-bottom:5px;">';
            
            if (isset($log['type']) && $log['type'] == 'sql') {
                echo '<strong>SQL:</strong> ' . htmlspecialchars($log['query']) . '<br>';
                if (!empty($log['params'])) {
                    echo '<strong>Params:</strong> ' . htmlspecialchars(json_encode($log['params'])) . '<br>';
                }
            } else {
                echo '<strong>Message:</strong> ' . htmlspecialchars($log['message']) . '<br>';
                if ($log['data'] !== null) {
                    echo '<strong>Data:</strong> ' . htmlspecialchars(json_encode($log['data'])) . '<br>';
                }
            }
            
            echo '</div>';
        }
        
        echo '</div>';
    }
}

// 디버그 모드 활성화 (개발 환경에서만)
if (defined('_PS_MODE_DEV_') && _PS_MODE_DEV_) {
    SegmentDebug::enable(true);
}

// 세그먼트 클래스에 디버깅 코드 추가
protected function findMatchingCustomers($limit = 1000, $offset = 0)
{
    // SQL 쿼리 생성 로직...
    
    SegmentDebug::logQuery($sql); // SQL 쿼리 로깅
    
    $result = Db::getInstance()->executeS($sql);
    SegmentDebug::log('Found matching customers', count($result)); // 결과 로깅
    
    return $result;
}

// classes/SegmentProfiler.php
class SegmentProfiler
{
    private static $timers = [];
    private static $enabled = false;
    
    // 프로파일러 활성화/비활성화
    public static function enable($enabled = true)
    {
        self::$enabled = $enabled;
    }
    
    // 타이머 시작
    public static function startTimer($name)
    {
        if (!self::$enabled) {
            return;
        }
        
        self::$timers[$name] = [
            'start' => microtime(true),
            'end' => null,
            'duration' => null,
            'memory_start' => memory_get_usage(),
            'memory_end' => null,
            'memory_peak' => null
        ];
    }
    
    // 타이머 종료
    public static function endTimer($name)
    {
        if (!self::$enabled || !isset(self::$timers[$name])) {
            return;
        }
        
        self::$timers[$name]['end'] = microtime(true);
        self::$timers[$name]['duration'] = self::$timers[$name]['end'] - self::$timers[$name]['start'];
        self::$timers[$name]['memory_end'] = memory_get_usage();
        self::$timers[$name]['memory_peak'] = memory_get_peak_usage();
    }
    
    // 결과 가져오기
    public static function getResults()
    {
        return self::$timers;
    }
    
    // 결과 출력
    public static function displayResults()
    {
        if (!self::$enabled || empty(self::$timers)) {
            return;
        }
        
        echo '<div class="segment-profiler-panel" style="position:fixed; top:0; right:0; width:400px; height:300px; overflow:auto; background:#fff; border:1px solid #ccc; padding:10px; z-index:9999;">';
        echo '<h3>Segment Profiler</h3>';
        echo '<table style="width:100%; border-collapse:collapse;">';
        echo '<tr><th style="text-align:left;">Operation</th><th>Time (ms)</th><th>Memory (MB)</th></tr>';
        
        foreach (self::$timers as $name => $timer) {
            if ($timer['end'] === null) {
                continue; // 종료되지 않은 타이머 건너뛰기
            }
            
            $duration_ms = round($timer['duration'] * 1000, 2);
            $memory_mb = round(($timer['memory_peak'] - $timer['memory_start']) / 1024 / 1024, 2);
            
            echo '<tr>';
            echo '<td>' . htmlspecialchars($name) . '</td>';
            echo '<td style="text-align:right;">' . $duration_ms . '</td>';
            echo '<td style="text-align:right;">' . $memory_mb . '</td>';
            echo '</tr>';
        }
        
        echo '</table>';
        echo '</div>';
    }
}

// 세그먼트 업데이트 메소드에 프로파일링 추가
public function updateCustomers($batch_size = 1000)
{
    SegmentProfiler::startTimer('updateCustomers');
    
    // 기존 코드...
    
    SegmentProfiler::endTimer('updateCustomers');
    return $total_inserted;
}

#!/bin/bash
# build.sh - 모듈 패키징 스크립트

# 변수 설정
MODULE_NAME="customer_segmentation"
VERSION=$(grep -o "version = '[0-9.]*'" ${MODULE_NAME}.php | cut -d "'" -f 2)
OUTPUT_FILE="${MODULE_NAME}-${VERSION}.zip"

# 임시 디렉토리 생성
echo "Creating temporary directory..."
mkdir -p ./build

# 필요한 파일 복사
echo "Copying module files..."
cp -r ./* ./build/
cd ./build

# 불필요한 파일 제거
echo "Removing unnecessary files..."
rm -rf .git .gitignore .idea tests build.sh
find . -name "*.log" -type f -delete
find . -name ".DS_Store" -type f -delete

# ZIP 파일 생성
echo "Creating ZIP file..."
cd ..
zip -r ${OUTPUT_FILE} ./build/*

# 임시 디렉토리 정리
echo "Cleaning up..."
rm -rf ./build

echo "Module packaged successfully: ${OUTPUT_FILE}"

// upgrade/upgrade-1.1.0.php
<?php
if (!defined('_PS_VERSION_')) {
    exit;
}

function upgrade_module_1_1_0($module)
{
    // 데이터베이스 업데이트
    $sql = [];
    
    // 새 테이블 추가
    $sql[] = 'CREATE TABLE IF NOT EXISTS `' . _DB_PREFIX_ . 'customer_segment_tag` (
        `id_segment_tag` int(10) unsigned NOT NULL AUTO_INCREMENT,
        `id_segment` int(10) unsigned NOT NULL,
        `name` varchar(64) NOT NULL,
        `color` varchar(7) DEFAULT NULL,
        PRIMARY KEY (`id_segment_tag`),
        KEY `id_segment` (`id_segment`)
    ) ENGINE=' . _MYSQL_ENGINE_ . ' DEFAULT CHARSET=utf8;';
    
    // 기존 테이블 수정
    $sql[] = 'ALTER TABLE `' . _DB_PREFIX_ . 'customer_segment` 
              ADD COLUMN `priority` int(10) unsigned NOT NULL DEFAULT 0 AFTER `active`;';
    
    // SQL 실행
    foreach ($sql as $query) {
        if (Db::getInstance()->execute($query) == false) {
            return false;
        }
    }
    
    // 설정 업데이트
    Configuration::updateValue('SEGMENT_AUTO_UPDATE', 1);
    
    // 새 훅 등록
    $module->registerHook('actionAdminCustomersListingFieldsModifier');
    
    return true;
}

# 유지보수 계획

## 버전 관리
- 메이저 버전 (x.0.0): 주요 기능 추가 또는 호환성이 깨지는 변경
- 마이너 버전 (0.x.0): 새로운 기능 추가 (하위 호환성 유지)
- 패치 버전 (0.0.x): 버그 수정 및 성능 개선

## 릴리스 일정
- 정기 업데이트: 분기별 (3개월마다)
- 보안 패치: 필요 시 즉시 배포
- 프레스토샵 메이저 버전 출시 후 2주 이내 호환성 업데이트

## 지원 정책
- 최신 버전 및 직전 버전에 대한 전체 지원
- 그 이전 버전은 보안 패치만 제공
- 지원 기간: 최소 1년

## 문서화
- 각 릴리스마다 CHANGELOG.md 업데이트
- 주요 변경사항에 대한 블로그 포스트 작성
- 사용자 매뉴얼 업데이트

## 테스트 계획
- 모든 릴리스 전 자동화된 테스트 수행
- 베타 테스터 그룹을 통한 실제 환경 테스트
- 성능 테스트 및 보안 검토

# 고객 세그먼테이션 모듈 사용자 매뉴얼

## 1. 소개
   - 모듈 개요
   - 주요 기능
   - 시스템 요구사항

## 2. 설치 및 설정
   - 모듈 설치 방법
   - 초기 설정
   - 권한 설정

## 3. 세그먼트 관리
   - 세그먼트 생성
   - 세그먼트 규칙 설정
   - 세그먼트 활성화/비활성화
   - 세그먼트 삭제

## 4. 규칙 유형
   - 고객 속성 규칙
   - 주문 기반 규칙
   - 제품 구매 규칙
   - 행동 기반 규칙

## 5. 마케팅 기능
   - 세그먼트 기반 이메일 발송
   - 할인 쿠폰 생성
   - 타겟 마케팅 캠페인

## 6. 보고서 및 분석
   - 세그먼트 성과 분석
   - 고객 행동 분석
   - 마케팅 캠페인 효과 측정

## 7. 고급 기능
   - API 활용
   - 외부 시스템 연동
   - 자동화 설정

## 8. 문제 해결
   - 일반적인 문제 및 해결 방법
   - 오류 메시지 설명
   - 지원 요청 방법

## 9. FAQ
   - 자주 묻는 질문 및 답변