import base64
import json
import struct
from flask import Flask, request, jsonify

app = Flask(__name__)

# 固定的参数值
SUBTITLE_HEADER = "subc"
EXAMPLE_SIGNATURE = "此处替换为客户调用StartSubtitle接口传入的signature即可"


# 定义字幕消息的数据结构
class SubtitleMessage:
    def __init__(self, type: str, data: list):
        self.type = type
        self.data = data


class SubtitleData:
    def __init__(self, text: str, language: str, user_id: str, sequence: int, definite: bool, paragraph: bool):
        self.text = text
        self.language = language
        self.user_id = user_id
        self.sequence = sequence
        self.definite = definite
        self.paragraph = paragraph


def parse_subtitle_message(message: str) -> SubtitleMessage:
    try:
        decoded_data = base64.b64decode(message)
    except Exception as e:
        raise ValueError(f"Base64 decoding failed: {e}")

    if len(decoded_data) < 8:
        raise ValueError("Data invalid: length is less than 8 bytes")

    magic_number = decoded_data[:4].decode()  # 前4个字节为 magic number
    if magic_number != SUBTITLE_HEADER:
        raise ValueError(f"Invalid magic number. Expected '{SUBTITLE_HEADER}', but got '{magic_number}'")

    # 提取字幕消息长度（4字节，Big-endian）
    length = struct.unpack(">I", decoded_data[4:8])[0]
    if len(decoded_data) != length + 8:
        raise ValueError(f"Size mismatch. Expected {length + 8}, but got {len(decoded_data)}")

    # 提取字幕消息详细信息
    subtitle_message_data = decoded_data[8:]
    try:
        subtitle_message_dict = json.loads(subtitle_message_data)
    except Exception as e:
        raise ValueError(f"JSON parsing failed: {e}")

    # 验证字幕消息的 type
    if subtitle_message_dict.get("type") != "subtitle":
        raise ValueError(f"Invalid type. Expected 'subtitle', but got '{subtitle_message_dict.get('type')}'")

    # 构造 SubtitleMessage 对象
    data_list = subtitle_message_dict.get("data", [])
    subtitle_data_objects = [
        SubtitleData(
            text=item.get("text"),
            language=item.get("language"),
            user_id=item.get("userId"),
            sequence=item.get("sequence"),
            definite=item.get("definite"),
            paragraph=item.get("paragraph")
        )
        for item in data_list
    ]
    return SubtitleMessage(type=subtitle_message_dict["type"], data=subtitle_data_objects)


@app.route("/", methods=["POST"])
def handle_subtitle():
    try:
        request_data = request.get_json(force=True)
        message = request_data.get("message")
        signature = request_data.get("signature")
    except Exception as e:
        print(f"Request JSON parsing failed: {e}")
        return jsonify({"error": "Invalid request format"}), 400

    if signature != EXAMPLE_SIGNATURE:
        print("Signature mismatch")
        return jsonify({"error": "Unauthorized"}), 403

    # 解析字幕消息
    try:
        subtitle_message = parse_subtitle_message(message)
        print("Parsed subtitle message:", subtitle_message)

        for subtitle_data in subtitle_message.data:
            print(f"[Subtitle] Text: {subtitle_data.text}, Language: {subtitle_data.language}, "
                  f"User ID: {subtitle_data.user_id}, Sequence: {subtitle_data.sequence}, "
                  f"Definite: {subtitle_data.definite}, Paragraph: {subtitle_data.paragraph}")

        return jsonify({"status": "ok"}), 200
    except Exception as e:
        print(f"Subtitle message parsing failed: {e}")
        return jsonify({"error": str(e)}), 500


if __name__ == "__main__":
    app.run(debug=True)

//数据格式
public class SubtitleMsgData {
    public boolean definite;
    public String language;
    public boolean paragraph;
    public int sequence;
    public String text;
    public String userId;

    @Override
    public String toString() {
        return "SubtitleMsgData{" +
                "definite=" + definite +
                ", language='" + language + ''' +
                ", paragraph=" + paragraph +
                ", sequence=" + sequence +
                ", text='" + text + ''' +
                ", userId='" + userId + ''' +
                '}';
    }
}

//回调
public void onRoomBinaryMessageReceived(String uid, ByteBuffer buffer) {
    StringBuilder subtitles = new StringBuilder();
    boolean ret = unpack(buffer, subtitles); 
    if (ret) {
        parseData(subtitles.toString());
    }
}

// 拆包校验
public static boolean unpack(ByteBuffer message, StringBuilder subtitles) {
    final int kSubtitleHeaderSize = 8;
    if (message.remaining() < kSubtitleHeaderSize) {
        return false;
    }

    // 魔法数字 "subc"
    int magicNumber = (message.get() << 24) | (message.get() << 16) | (message.get() << 8) | (message.get());
    if (magicNumber != 0x73756276) {
        return false;
    }

    int length = message.getInt();

    if (message.remaining() != length) {
        return false;
    }

    // 读取字幕内容
    byte[] subtitleBytes = new byte[length];
    message.get(subtitleBytes);
    subtitles.append(new String(subtitleBytes, StandardCharsets.UTF_8));

    return true;
}

// 解析字幕消息
public static void parseData(String msg) {
    try {
        // 解析 JSON 字符串
        ObjectMapper objectMapper = new ObjectMapper();
        JsonNode jsonData = objectMapper.readTree(msg);

        // 存储解析后的数据
        List<SubtitleMsgData> subtitles = new ArrayList<>();

        // 遍历 JSON 数据并填充结构体
        for (JsonNode item : jsonData.get("data")) {
            SubtitleMsgData subData = new SubtitleMsgData();
            subData.definite = item.get("definite").asBoolean();
            subData.language = item.get("language").asText();
            subData.paragraph = item.get("paragraph").asBoolean();
            subData.sequence = item.get("sequence").asInt();
            subData.text = item.get("text").asText();
            subData.userId = item.get("userId").asText();
            subtitles.add(subData);
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
}

//数据格式
@interface SubtitleMsgData : NSObject

@property (nonatomic, assign) BOOL definite;
@property (nonatomic, copy) NSString *language;
@property (nonatomic, assign) BOOL paragraph;
@property (nonatomic, assign) NSInteger sequence;
@property (nonatomic, copy) NSString *text;
@property (nonatomic, copy) NSString *userId;

@end

@implementation SubtitleMsgData
@end

//回调
- (void)rtcRoom:( ByteRTCRoom *_Nonnull)rtcRoom onRoomBinaryMessageReceived:(NSString *_Nonnull)uid message:(NSData *_Nonnull)message {
    NSString *subtitles = unpack(buffer);
    if (subtitles) {
        parseData(subtitles);
    }
}


// 大端序转换
uint32_t swapUInt32(uint32_t value) {
    return ((value & 0x000000FF) << 24) |
           ((value & 0x0000FF00) << 8) |
           ((value & 0x00FF0000) >> 8) |
           ((value & 0xFF000000) >> 24);
}

//拆包校验
NSString *unpack(NSData *data) {
    const int kSubtitleHeaderSize = 8;
    NSUInteger size = data.length;
    if (size < kSubtitleHeaderSize) {
        return nil;
    }
    const uint8_t *message = data.bytes;
    // Check magic number "subc"
    uint32_t magic = (message[0] << 24) | (message[1] << 16) | (message[2] << 8) | message[3];
    if (magic != 0x73756276) {
        return nil;
    }
    
    // Get length
    uint32_t length = (message[4] << 24) | (message[5] << 16) | (message[6] << 8) | message[7];
    if (size - kSubtitleHeaderSize != length) {
        return nil;
    }
    
    // Get subtitles
    NSString *subtitles = nil;
    if (length > 0) {
        subtitles = [[NSString alloc] initWithBytes:message + kSubtitleHeaderSize length:length encoding:NSUTF8StringEncoding];
    } else {
        subtitles = @"";
    }
    
    return subtitles;
}
//解析
void parseData(NSString *msg) {
    NSError *error = nil;
    NSDictionary *json_data = [NSJSONSerialization JSONObjectWithData:[msg dataUsingEncoding:NSUTF8StringEncoding] options:0 error:&error];
    
    if (error) {
        NSLog(@"JSON Parse Error: %@", error);
        return;
    }
    
    NSMutableArray<SubtitleMsgData *> *subtitles = [NSMutableArray array];
    
    for (NSDictionary *item in json_data[@"data"]) {
        SubtitleMsgData *subData = [[SubtitleMsgData alloc] init];
        subData.definite = [item[@"definite"] boolValue];
        subData.language = item[@"language"];
        subData.paragraph = [item[@"paragraph"] boolValue];
        subData.sequence = [item[@"sequence"] integerValue];
        subData.text = item[@"text"];
        subData.userId = item[@"userId"];
        
        [subtitles addObject:subData];
    }
}