# Time-Series Transformer 架构示意
class TimeSeriesTransformer(nn.Module):
    def __init__(self, input_dim, d_model, n_heads, n_layers):
        self.embedding = nn.Linear(input_dim, d_model)
        self.positional_encoding = PositionalEncoding(d_model)
        self.transformer = nn.TransformerEncoder(
            nn.TransformerEncoderLayer(d_model, n_heads),
            num_layers=n_layers
        )
        self.fc = nn.Linear(d_model, 1)

class FermentationController:
    def __init__(self, predictor, policy_model):
        self.predictor = predictor
        self.policy = policy_model  # 可为 PID、模糊控制或 RL
    
    def compute_action(self, current_state):
        # 预测下一步状态
        predicted_state = self.predictor.predict(current_state)
        
        # 计算最优控制动作
        action = self.policy.compute(
            target=current_state.target_od,
            predicted=predicted_state
        )
        
        return action
    
    def execute_and_correct(self, action):
        # 发送控制指令到执行器
        result = self.actuator.execute(action)
        
        # 获取新的传感器数据
        new_state = self.sensor.read()
        
        # 校正预测误差
        self.predictor.correct(new_state)
        
        return new_state

class FermentationEnv(gym.Env):
    def __init__(self):
        self.state_space = Box(low=..., high=..., shape=(12,))  # 12维状态
        self.action_space = Box(low=..., high=..., shape=(5,))  # 5维控制
        
    def step(self, action):
        # 执行控制动作
        self.execute_control(action)
        
        # 获取新状态
        new_state = self.sensor.read()
        
        # 计算奖励（OD600 增长速率）
        reward = self.compute_reward(new_state)
        
        # 判断是否结束
        done = self.check_termination(new_state)
        
        return new_state, reward, done, {}
    
    def reset(self):
        return self.sensor.read_initial()

# 分布式训练框架
agent = PPOAgent(
    observation_space=env.state_space,
    action_space=env.action_space,
    model_config={"hidden_dim": 256, "n_layers": 3}
)

# 与发酵环境交互训练
for episode in range(1000):
    state = env.reset()
    episode_reward = 0
    
    while not done:
        action = agent.select_action(state)
        next_state, reward, done, _ = env.step(action)
        agent.store_transition(state, action, reward, next_state, done)
        agent.train()
        state = next_state
        episode_reward += reward

class MultiFermenterOptimizer:
    def __init__(self, num_reactors):
        self.reactors = [FermenterPredictor() for _ in range(num_reactors)]
        self.optimizer = BatchOptimizer()
    
    def optimize_batch_allocation(self, total_resources):
        """优化批次分配策略"""
        allocations = {}
        remaining = total_resources.copy()
        
        for reactor_id, pred in enumerate(self.reactors):
            # 计算各发酵罐的边际收益
            marginal_returns = pred.compute_marginal_return(remaining)
            
            # 贪心分配
            best_reactor = max(marginal_returns, key=marginal_returns.get)
            allocations[best_reactor] = remaining[best_reactor] * 0.2
            
        return allocations

# 插件接口定义
class FermentationPlugin(ABC):
    @abstractmethod
    def initialize(self, config: dict):
        pass
    
    @abstractmethod
    def on_data_received(self, data: SensorData):
        pass
    
    @abstractmethod
    def on_prediction_ready(self, prediction: Prediction):
        pass

# 插件示例：异常检测
class AnomalyDetectionPlugin(FermentationPlugin):
    def __init__(self, threshold=3.0):
        self.threshold = threshold
        self.statistics = RunningStatistics()
    
    def on_prediction_ready(self, prediction: Prediction):
        z_score = self.statistics.compute_zscore(prediction.value)
        if abs(z_score) > self.threshold:
            self.trigger_alert(prediction, z_score)

def create_app(config_path: Optional[str] = None) -> Flask:
    config = APIConfig(config_path)
    setup_logging(config)
    
    app = Flask(__name__)
    app.config["JSON_AS_ASCII"] = False

class APIConfig:
    _instance = None
    _lock = threading.Lock()
    
    def __new__(cls, config_path: Optional[str] = None):
        if cls._instance is None:
            with cls._lock:
                if cls._instance is None:
                    cls._instance = super().__new__(cls)
        return cls._instance

@app.route("/api/health", methods=["GET"])
def health_check():
    return jsonify({
        "success": True,
        "data": {
            "status": "healthy",
            "timestamp": datetime.utcnow().isoformat() + "Z"
        }
    }), 200

@app.route("/api/status", methods=["GET"])
def status():
    db_connector = DatabaseConnector()
    db_health = db_connector.health_check_all()
    raw_data_count = raw_data_ops.count()
    
    return jsonify({
        "success": True,
        "data": {
            "status": "running",
            "timestamp": datetime.utcnow().isoformat() + "Z",
            "database": db_health,
            "statistics": {"raw_data_count": raw_data_count}
        }
    }), 200

@app.route("/api/raw_data", methods=["POST"])
def create_raw_data():
    if not request.is_json:
        return jsonify({"success": False, "error": {...}}), 400
    
    data = request.get_json()
    
    # 批量插入
    if isinstance(data, list):
        max_batch = config.get("performance.max_batch_size", 1000)
        if len(data) > max_batch:
            return jsonify({"success": False, "error": {...}}), 400
        
        # 验证所有记录
        errors = []
        for i, record in enumerate(data):
            is_valid, error_msg = data_validator.validate_raw_data(record)
            if not is_valid:
                errors.append(f"Record {i}: {error_msg}")
        
        # 批量插入数据库
        normalized_records = [data_validator.normalize_data(r) for r in data]
        inserted_count = raw_data_ops.batch_insert(normalized_records)
        
        return jsonify({
            "success": True,
            "data": {"inserted_count": inserted_count}
        }), 201

@app.route("/api/raw_data/latest", methods=["GET"])
def get_latest_raw_data():
    batch_id = request.args.get("batch_id")
    record = raw_data_ops.get_latest(batch_id)
    
    if record is None:
        return jsonify({"success": True, "data": None}), 200
    
    # 转换 datetime 为 ISO 格式
    if "timestamp" in record and isinstance(record["timestamp"], datetime):
        record["timestamp"] = record["timestamp"].isoformat()
    
    return jsonify({"success": True, "data": record}), 200

class DataValidator:
    def validate_raw_data(self, data: Dict[str, Any]) -> tuple[bool, Optional[str]]:
        required_fields = ["timestamp", "batch_id"]
        for field in required_fields:
            if field not in data or data[field] is None:
                return False, f"Required field '{field}' is missing"
        
        # 字段类型检查
        field_types = self.validation_rules.get("field_types", {})
        for field, expected_type in field_types.items():
            if expected_type == "datetime" and not self._is_valid_datetime(value):
                return False, f"Field '{field}' must be a valid datetime"
        
        # 数值范围检查
        field_ranges = {"od_600": {"min": 0, "max": 200}}
        for field, range_config in field_ranges.items():
            num_value = float(data[field])
            if num_value < range_config["min"] or num_value > range_config["max"]:
                return False, f"Field '{field}' exceeds valid range"

def normalize_data(self, data: Dict[str, Any]) -> Dict[str, Any]:
    normalized = {}
    for key, value in data.items():
        if value is None:
            normalized[key] = None
            continue
        
        # 类型转换
        if expected_type == "datetime" and isinstance(value, str):
            normalized[key] = datetime.fromisoformat(value.replace("Z", "+00:00"))
        elif expected_type == "float":
            normalized[key] = float(value)
        else:
            normalized[key] = value
    
    return normalized

class ConnectionPool:
    def __init__(self, db_config, pool_size=5, timeout=30.0, driver="pymysql"):
        self._pool: Queue = Queue(maxsize=pool_size)
        self._lock = threading.Lock()
        
        # 预创建连接
        for _ in range(pool_size):
            conn = self._create_connection()
            self._pool.put(conn)
    
    def get_connection(self, timeout=None):
        try:
            conn = self._pool.get(block=True, timeout=timeout)
            # 检查连接是否存活
            if not self._is_connection_alive(conn):
                conn = self._create_connection()
            return conn
        except Empty:
            # 连接池耗尽时创建新连接
            return self._create_connection()
    
    def release_connection(self, conn):
        if self._is_connection_alive(conn):
            self._pool.put(conn, block=False)
        else:
            conn.close()

def health_check(self) -> Dict[str, Any]:
    alive_count = 0
    dead_count = 0
    temp_connections = []
    
    while not self._pool.empty():
        conn = self._pool.get_nowait()
        if self._is_connection_alive(conn):
            alive_count += 1
            temp_connections.append(conn)
        else:
            dead_count += 1
            conn.close()
    
    # 归还连接
    for conn in temp_connections:
        self._pool.put(conn)
    
    return {
        "pool_size": self.pool_size,
        "alive_connections": alive_count,
        "dead_connections": dead_count
    }

class IPWhitelist:
    def is_allowed(self, client_ip: str) -> bool:
        if not self.enabled:
            return True
        
        ip = ipaddress.ip_address(client_ip)
        for item in self.whitelist:
            if isinstance(item, ipaddress.IPv4Network):
                if ip in item:
                    return True
            elif ip == item:
                return True
        return False

@app.after_request
def after_request(response):
    elapsed_ms = (time.time() - g.start_time) * 1000
    response.headers["X-Response-Time-ms"] = f"{elapsed_ms:.2f}"
    
    # 慢请求警告
    if elapsed_ms > 500:
        logging.warning(f"Slow request: {request.method} {request.path}")
    
    return response

response.headers["X-Content-Type-Options"] = "nosniff"
response.headers["X-Frame-Options"] = "DENY"

class ParameterOptimizer:
    def __init__(self, param_names, param_bounds, model, test_dataset, ...):
        self.pop_size = 50          # 种群规模
        self.n_generations = 100    # 进化代数
        self.mutation_rate = 0.1    # 变异率

def _initialize_population(self, base_params):
    population = []
    for _ in range(self.pop_size):
        ind = base_params.copy()
        for i in range(self.n_params):
            # 以 base_params 为中心，添加高斯噪声
            ind[i] += np.random.normal(0, self.param_bounds[i][1]*0.1)
            # 限制在边界范围内
            ind[i] = np.clip(ind[i], *self.param_bounds[i])
        population.append(ind)
    return np.array(population)

def _evaluate(self, individual, baseline):
    # 将参数归一化
    optimized_params_norm = self._normalize_individual(individual)
    
    # 更新数据集的最后一行窗口
    self.test_dataset.update_specific_window(optimized_params_norm)
    
    # 使用 LSTM 模型预测
    output, h = self.model(input.float().unsqueeze(0), h)
    y_scalar = output.view(-1).cpu().numpy()[-1]
    
    # 反归一化得到实际 OD600 值
    preds_denorm = y_scalar * self.y_std + self.y_mean
    current_od600 = preds_denorm
    
    return current_od600

def _select(self, population, fitness):
    if len(population) <= 2:
        return population
    # 选择适应度最高的前 50% 个体
    return population[np.argsort(fitness)[-int(self.pop_size*0.5):]]

def _crossover_mutate(self, selected):
    new_pop = []
    while len(new_pop) < self.pop_size:
        # 随机选择两个父代
        indices = np.random.permutation(len(selected))[:2]
        parents = selected[indices]
        
        # 平均交叉
        child = (parents[0] + parents[1]) / 2
        
        # 变异操作
        for i in range(self.n_params):
            if np.random.rand() < self.mutation_rate:
                child[i] += np.random.normal(0, self.param_bounds[i][1]*0.2)
                child[i] = np.clip(child[i], *self.param_bounds[i])
        
        new_pop.append(child)
    return np.array(new_pop)

def optimize(self, initial_params, initial_score):
    # 初始化种群
    population = self._initialize_population(initial_params)
    self.best_params = initial_params
    
    # 进化循环
    for gen in tqdm(range(self.n_generations), desc="Generations"):
        # 评估所有个体的适应度
        fitness = np.array([self._evaluate(ind, initial_score) for ind in population])
        
        # 选择
        selected = self._select(population, fitness)
        
        # 交叉变异生成新种群
        population = self._crossover_mutate(selected)
    
    return self.best_params

param_names = ["温度", "pH", "溶解氧", "搅拌速率", "补料速率"]
param_bounds = [
    (30, 40),      # 温度: 30-40°C
    (6.5, 7.5),    # pH: 6.5-7.5
    (20, 100),     # 溶解氧: 20-100%
    (100, 500),    # 搅拌速率: 100-500 RPM
    (0, 50)        # 补料速率: 0-50 mL/h
]

# 可使用 NSGA-II 算法同时优化多个目标
# - OD600（细胞密度）最大化
# - 发酵时间最小化
# - 底物消耗最小化

# 根据进化进程动态调整变异率
if generation > n_generations * 0.8:
    mutation_rate = 0.05  # 后期降低变异率，精细搜索
else:
    mutation_rate = 0.15   # 前期保持较高变异率

def _evaluate_with_constraints(self, individual):
    penalty = 0
    if individual[0] > 40:  # 温度超限
        penalty += 1000
    fitness = self._evaluate(individual) - penalty
    return fitness