import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestRegressor
from sklearn.metrics import mean_squared_error
from scipy.optimize import minimize
from flask import Flask, request, jsonify

app = Flask(__name__)


# 解冻时间计算函数
def calculate_defrost_time(w, data):
    # 物理参数1
    rho_ice = data['rho_ice']  # 冰的密度
    C_ice = data['C_ice']  # 冰的比热容
    L = data['L']  # 冰的潜热
    k_ice = data['k_coal']  # 冰的导热系数
    T_m = data['T_m']  # 熔点温度（摄氏度）
    rho_coal = data['rho_coal']  # 物料的密度
    C_coal = data['C_coal']  # 物料的比热容
    k_coal = data['k_coal']  # 物料的导热系数
    h = data['h']  # 对流换热系数
    T_air = data['T_air']  # 空气温度（摄氏度）
    T_initial = data['T_initial']  # 物料初始温度
    a, b, c = data['a'], data['b'], data['c']  # 车厢的尺寸（长、宽、高）
    # 计算体积和表面积
    V = a * b * c
    A = 2 * (a * b) + 2 * (b * c) + 2 * (a * c)
    # 计算混合密度
    rho_mix = (1 - w) * rho_coal + w * rho_ice
    # 计算混合比热容
    C_mix = (1 - w) * C_coal + w * C_ice
    # 计算特征长度
    L_char = V / A
    # 计算体积分数
    phi = (w * rho_coal) / rho_ice
    # 计算有效导热系数
    k_eff = (k_coal * (2 * k_coal + k_ice - 2 * phi * (k_coal - k_ice)) /
             (2 * k_coal + k_ice + phi * (k_coal - k_ice))) + 1.1
    # 初步解冻时间 t1（小时）
    t1 = ((0.2 * rho_mix * C_mix * L_char ** 2) / k_eff *
          ((T_m - T_initial) / (T_air - T_initial))) / 3600
    # 进一步解冻时间 t2（小时）
    k_char = h  # 近似处理 k_char
    t2 = ((rho_mix * w * L * L_char * L_char / (k_eff * (T_air - T_m))) *
          ((0.5 + k_eff / (k_char * L_char)) / 6)) / 3600
    # 总解冻时间
    t_total = t1 + t2
    return t_total


def calculate_jt_time(w, data):
    # 提取参数
    m_ice = data.get("m_coal") * w  # 冰的质量 (kg)
    c_ice = data.get("C_ice")  # 冰的比热容 (J/kg·K)
    delta_T_initial = data.get("delta_T_initial")  # 初始温差 (K)
    L = data.get("L")  # 冰的熔化潜热 (J/kg)
    m_coke = data.get("m_coal") - m_ice  # 焦炭质量 (kg)
    c_coke = data.get("C_coal")  # 焦炭的比热容 (J/kg·K)
    h = data.get("h")  # 对流换热系数 (W/m²·K)
    a, b, c = data['a'], data['b'], data['c']  # 车厢的尺寸（长、宽、高）
    A = 2 * (a * b) + 2 * (b * c) + 2 * (a * c)  # 有效传热面积 (m²)
    delta_T_heat = data.get("delta_T_heat")  # 热风温差 (K)

    # 计算总热量需求
    Q_ice = m_ice * (c_ice * delta_T_initial + L)
    Q_coke = m_coke * c_coke * delta_T_initial
    Q_total = Q_ice + Q_coke

    # 计算总热传递能力
    Q_transfer = h * A * delta_T_heat

    # 计算时间 (秒)
    t_seconds = Q_total / Q_transfer

    # 转换为小时
    t_hours = t_seconds / 3600

    return t_hours


# 反推函数
def reverse_calculate(time, data):
    def objective_function(vars):
        w = vars
        if data.get("meterial_type") == 1:
            calculated_time = calculate_defrost_time(w, data)
        else:
            calculated_time = calculate_jt_time(w, data)
        return abs(calculated_time - time)

    bounds = [(0.1, 0.5)]  # 含水量和初始温度的范围
    num_trials = 10  # 尝试的次数
    best_result = None
    best_error = np.inf
    for _ in range(num_trials):
        # 随机生成初始猜测值
        initial_guess = [np.random.uniform(0.1, 0.15)]
        result = minimize(objective_function, initial_guess, bounds=bounds)
        error = result.fun
        if error < best_error:
            best_error = error
            best_result = result
    return best_result.x[0]


# API 入口
@app.route('/reverse_calculate', methods=['POST'])
def handle_request():
    try:
        data = request.get_json()
        qq = data.get("meterial_type");
        print(f"算法区分{qq}")
        time = float(data['realThawTime'])
        w_result = reverse_calculate(time, data)
        print(f"实际用时{time}")
        print(f"含水量{round(w_result * 100, 2)}")
        return jsonify({
            "water_content": round(w_result * 100, 2)
        })
    except Exception as e:
        return jsonify({"error": str(e)}), 400


if __name__ == '__main__':
    app.run(host='127.0.0.1', port=9993, debug=True)