class BinaryContactArray:
    """
    二进制接触传感阵列
    
    硬件配置：
    - 10个机械接触开关
    - 5行 × 2列排列
    - 安装在座椅靠背
    
    每个开关输出：0（无接触）或 1（有接触）
    总信息量：2^10 = 1024 种可能的接触模式
    """
    
    def __init__(self):
        # 开关布局（5行 × 2列）
        self.layout = {
            'row_1_top': ['left_shoulder', 'right_shoulder'],
            'row_2': ['left_upper_back', 'right_upper_back'],
            'row_3_center': ['left_center_back', 'right_center_back'],
            'row_4': ['left_lower_back', 'right_lower_back'],
            'row_5_bottom': ['left_lumbar', 'right_lumbar'],
        }
        
        # 四种目标姿态
        self.postures = {
            'normal': '正常坐姿',
            'leaning_back': '后仰',
            'leaning_left': '左倾',
            'leaning_right': '右倾'
        }
    
    def get_binary_signature(self, switch_states):
        """
        将 10 个开关状态转为 10-bit 签名
        
        Args:
            switch_states: dict, 10个开关的开关状态 (0/1)
        Returns:
            signature: 10-bit numpy array
        """
        sig = np.array([
            switch_states.get('left_shoulder', 0),
            switch_states.get('right_shoulder', 0),
            switch_states.get('left_upper_back', 0),
            switch_states.get('right_upper_back', 0),
            switch_states.get('left_center_back', 0),
            switch_states.get('right_center_back', 0),
            switch_states.get('left_lower_back', 0),
            switch_states.get('right_lower_back', 0),
            switch_states.get('left_lumbar', 0),
            switch_states.get('right_lumbar', 0),
        ], dtype=np.int8)
        return sig
    
    def describe_pattern(self, sig):
        """描述接触模式"""
        active = np.where(sig == 1)[0]
        inactive = np.where(sig == 0)[0]
        return f"接触: {len(active)}/10, 活跃开关: {active.tolist()}"

from sklearn.tree import DecisionTreeClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import cross_val_score
import numpy as np

class PostureClassifier:
    """
    坐姿分类器
    
    论文使用两种分类器：
    1. 决策树（最佳性能）
    2. 逻辑回归（可解释性）
    """
    
    def __init__(self, method='decision_tree'):
        if method == 'decision_tree':
            self.model = DecisionTreeClassifier(
                max_depth=4,
                criterion='gini',
                random_state=42
            )
        else:
            self.model = LogisticRegression(
                max_iter=1000,
                multi_class='multinomial',
                solver='lbfgs'
            )
        self.method = method
        self.classes_ = None
        
    def fit(self, X, y):
        """
        Args:
            X: (N, 10) 二进制接触签名
            y: (N,) 姿态标签
        """
        self.model.fit(X, y)
        self.classes_ = self.model.classes_
        
        # 交叉验证
        cv_scores = cross_val_score(self.model, X, y, cv=5, scoring='accuracy')
        print(f"5折交叉验证准确率: {cv_scores.mean():.2%} (±{cv_scores.std():.2%})")
        
        return self
    
    def predict(self, X):
        return self.model.predict(X)
    
    def predict_proba(self, X):
        return self.model.predict_proba(X)
    
    def get_decision_rules(self):
        """提取决策树规则（可解释性）"""
        if self.method != 'decision_tree':
            return "仅决策树支持规则提取"
        
        # 手动构建规则（基于论文结果）
        rules = """
        决策树规则（基于论文 Figure 5）：
        
        IF left_center_back == 0 AND right_center_back == 0:
            → 后仰（远离靠背）
        ELIF left_shoulder == 0 AND left_upper_back == 0:
            → 右倾（右侧接触，左侧脱离）
        ELIF right_shoulder == 0 AND right_upper_back == 0:
            → 左倾（左侧接触，右侧脱离）
        ELSE:
            → 正常坐姿（中央区域接触）
        """
        return rules


def generate_synthetic_data():
    """生成合成训练数据（模拟论文实验）"""
    np.random.seed(42)
    
    samples = []
    labels = []
    
    # 正常坐姿：中央和上部接触，两侧对称
    for _ in range(100):
        sig = np.array([
            np.random.choice([0, 1], p=[0.1, 0.9]),  # left_shoulder
            np.random.choice([0, 1], p=[0.1, 0.9]),  # right_shoulder
            np.random.choice([0, 1], p=[0.05, 0.95]), # left_upper
            np.random.choice([0, 1], p=[0.05, 0.95]), # right_upper
            np.random.choice([0, 1], p=[0.02, 0.98]), # left_center
            np.random.choice([0, 1], p=[0.02, 0.98]), # right_center
            np.random.choice([0, 1], p=[0.1, 0.9]),  # left_lower
            np.random.choice([0, 1], p=[0.1, 0.9]),  # right_lower
            np.random.choice([0, 1], p=[0.2, 0.8]),  # left_lumbar
            np.random.choice([0, 1], p=[0.2, 0.8]),  # right_lumbar
        ])
        samples.append(sig)
        labels.append('normal')
    
    # 后仰：上部脱离，下部接触
    for _ in range(100):
        sig = np.array([
            np.random.choice([0, 1], p=[0.8, 0.2]),  # left_shoulder (脱离)
            np.random.choice([0, 1], p=[0.8, 0.2]),  # right_shoulder
            np.random.choice([0, 1], p=[0.7, 0.3]),  # left_upper
            np.random.choice([0, 1], p=[0.7, 0.3]),  # right_upper
            np.random.choice([0, 1], p=[0.5, 0.5]),  # left_center
            np.random.choice([0, 1], p=[0.5, 0.5]),  # right_center
            np.random.choice([0, 1], p=[0.2, 0.8]),  # left_lower
            np.random.choice([0, 1], p=[0.2, 0.8]),  # right_lower
            np.random.choice([0, 1], p=[0.1, 0.9]),  # left_lumbar
            np.random.choice([0, 1], p=[0.1, 0.9]),  # right_lumbar
        ])
        samples.append(sig)
        labels.append('leaning_back')
    
    # 左倾：右侧脱离
    for _ in range(100):
        sig = np.array([
            np.random.choice([0, 1], p=[0.9, 0.1]),  # left_shoulder (脱离)
            np.random.choice([0, 1], p=[0.1, 0.9]),  # right_shoulder
            np.random.choice([0, 1], p=[0.8, 0.2]),  # left_upper
            np.random.choice([0, 1], p=[0.1, 0.9]),  # right_upper
            np.random.choice([0, 1], p=[0.7, 0.3]),  # left_center
            np.random.choice([0, 1], p=[0.05, 0.95]),# right_center
            np.random.choice([0, 1], p=[0.6, 0.4]),  # left_lower
            np.random.choice([0, 1], p=[0.1, 0.9]),  # right_lower
            np.random.choice([0, 1], p=[0.5, 0.5]),  # left_lumbar
            np.random.choice([0, 1], p=[0.2, 0.8]),  # right_lumbar
        ])
        samples.append(sig)
        labels.append('leaning_left')
    
    # 右倾：左侧脱离
    for _ in range(100):
        sig = np.array([
            np.random.choice([0, 1], p=[0.1, 0.9]),  # left_shoulder
            np.random.choice([0, 1], p=[0.9, 0.1]),  # right_shoulder (脱离)
            np.random.choice([0, 1], p=[0.1, 0.9]),  # left_upper
            np.random.choice([0, 1], p=[0.8, 0.2]),  # right_upper
            np.random.choice([0, 1], p=[0.05, 0.95]),# left_center
            np.random.choice([0, 1], p=[0.7, 0.3]),  # right_center
            np.random.choice([0, 1], p=[0.1, 0.9]),  # left_lower
            np.random.choice([0, 1], p=[0.6, 0.4]),  # right_lower
            np.random.choice([0, 1], p=[0.2, 0.8]),  # left_lumbar
            np.random.choice([0, 1], p=[0.5, 0.5]),  # right_lumbar
        ])
        samples.append(sig)
        labels.append('leaning_right')
    
    return np.array(samples), np.array(labels)


# ==================== 测试 ====================

if __name__ == "__main__":
    print("=" * 60)
    print("二进制接触传感坐姿识别测试")
    print("=" * 60)
    
    # 生成数据
    X, y = generate_synthetic_data()
    print(f"数据集: {X.shape[0]} 样本, {X.shape[1]} 特征")
    print(f"类别: {np.unique(y)}")
    print(f"每类样本数: {[(c, (y==c).sum()) for c in np.unique(y)]}")
    
    # 训练决策树
    print("\n--- 决策树 ---")
    clf_dt = PostureClassifier(method='decision_tree')
    clf_dt.fit(X, y)
    print(clf_dt.get_decision_rules())
    
    # 训练逻辑回归
    print("\n--- 逻辑回归 ---")
    clf_lr = PostureClassifier(method='logistic')
    clf_lr.fit(X, y)
    
    # 测试
    test_cases = [
        ([1,1,1,1,1,1,1,1,0,1], "正常坐姿"),
        ([0,0,0,0,1,1,1,1,1,1], "后仰"),
        ([0,1,0,1,0,1,0,1,0,1], "左倾"),
        ([1,0,1,0,1,0,1,0,1,0], "右倾"),
    ]
    
    print("\n--- 测试用例 ---")
    for sig, expected in test_cases:
        sig_array = np.array(sig).reshape(1, -1)
        pred_dt = clf_dt.predict(sig_array)[0]
        proba = clf_dt.predict_proba(sig_array)[0]
        max_prob = max(proba)
        print(f"输入: {sig}")
        print(f"  期望: {expected}, 预测: {pred_dt}, 置信度: {max_prob:.2%}")
    
    # 开关重要性分析（SHAP 近似）
    print("\n--- 开关重要性（基于信息增益）---")
    if hasattr(clf_dt.model, 'feature_importances_'):
        names = ['L_shoulder', 'R_shoulder', 'L_upper', 'R_upper',
                'L_center', 'R_center', 'L_lower', 'R_lower',
                'L_lumbar', 'R_lumbar']
        importances = clf_dt.model.feature_importances_
        sorted_idx = np.argsort(importances)[::-1]
        for idx in sorted_idx:
            print(f"  {names[idx]:15s}: {importances[idx]:.4f}")

class SeatOOPDetection:
    """
    基于二进制接触开关的汽车座椅 OOP 检测
    
    优势：
    - 成本极低（10个开关 <$2）
    - 无需标定
    - 无隐私问题
    - 响应快（<1ms）
    
    局限：
    - 仅检测靠背方向姿态
    - 需要扩展到座垫和头枕
    """
    
    def __init__(self):
        # 扩展到汽车座椅：靠背 + 座垫
        self.seat_sensors = {
            'backrest': {
                'count': 10,  # 5×2 阵列
                'positions': '靠背（肩部到腰部）',
                'detects': ['前倾', '后仰', '左倾', '右倾']
            },
            'cushion': {
                'count': 6,   # 3×2 阵列
                'positions': '座垫（前部到后部）',
                'detects': ['前滑', '后滑', '坐姿不正']
            },
            'headrest': {
                'count': 2,   # 左右
                'positions': '头枕',
                'detects': ['头部位置', '身高推断']
            }
        }
        # 总计 18 个开关，成本 < $4
    
    def detect_oop(self, all_switches):
        """
        OOP 检测逻辑
        
        Args:
            all_switches: 18 个开关状态
        Returns:
            posture: str
            risk_level: int (0=正常, 1=注意, 2=警告, 3=危险)
        """
        backrest = all_switches[:10]
        cushion = all_switches[10:16]
        headrest = all_switches[16:18]
        
        # 检查异常模式
        if sum(backrest[:2]) == 0 and sum(backrest[2:4]) == 0:
            # 上半身完全脱离靠背
            return 'LEANING_FORWARD', 2
        
        if backrest[0] == 0 and backrest[2] == 0 and backrest[4] == 0:
            # 左侧完全脱离
            return 'LEANING_RIGHT', 2
        
        if backrest[1] == 0 and backrest[3] == 0 and backrest[5] == 0:
            # 右侧完全脱离
            return 'LEANING_LEFT', 2
        
        if sum(headrest) == 0 and sum(backrest[:4]) == 0:
            # 头部和上半身都脱离
            return 'STANDING_OR_KNEELING', 3
        
        if sum(cushion) < 2:
            # 座垫接触极少
            return 'NOT_SEATED', 3
        
        return 'NORMAL', 0