// ============================================================================
// block_serializer.c - JSON 序列化实现
// ============================================================================

#include "block_serializer.h"
#include "block_types.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// 简单的 JSON 生成器
typedef struct {
    char* buffer;
    size_t size;
    size_t capacity;
} JsonBuffer;

static void json_init(JsonBuffer* buf) {
    buf->capacity = 4096;
    buf->buffer = (char*)malloc(buf->capacity);
    buf->size = 0;
    buf->buffer[0] = '\0';
}

static void json_append(JsonBuffer* buf, const char* str) {
    size_t len = strlen(str);
    if (buf->size + len + 1 > buf->capacity) {
        buf->capacity = (buf->size + len + 1) * 2;
        buf->buffer = (char*)realloc(buf->buffer, buf->capacity);
    }
    memcpy(buf->buffer + buf->size, str, len + 1);
    buf->size += len;
}

static void json_free(JsonBuffer* buf) {
    free(buf->buffer);
    buf->buffer = NULL;
    buf->size = 0;
}

int serializer_save(BlockWorkspace* ws, const char* filepath) {
    char* json = serializer_save_to_string(ws);
    if (!json) return 0;
    
    FILE* f = fopen(filepath, "w");
    if (!f) {
        free(json);
        return 0;
    }
    
    fprintf(f, "%s", json);
    fclose(f);
    free(json);
    return 1;
}

int serializer_load(BlockWorkspace* ws, const char* filepath) {
    FILE* f = fopen(filepath, "r");
    if (!f) return 0;
    
    fseek(f, 0, SEEK_END);
    long size = ftell(f);
    fseek(f, 0, SEEK_SET);
    
    char* json = (char*)malloc(size + 1);
    fread(json, 1, size, f);
    json[size] = '\0';
    fclose(f);
    
    int result = serializer_load_from_string(ws, json);
    free(json);
    return result;
}

char* serializer_save_to_string(BlockWorkspace* ws) {
    JsonBuffer buf;
    json_init(&buf);
    
    json_append(&buf, "{\n");
    json_append(&buf, "  \"version\": \"1.0\",\n");
    
    // 保存积木
    json_append(&buf, "  \"blocks\": [\n");
    for (int i = 0; i < ws->block_count; i++) {
        Block* block = ws->blocks[i];
        const BlockTypeInfo* info = block_type_get_info(block->type);
        
        char tmp[256];
        snprintf(tmp, 256, "    {\n");
        json_append(&buf, tmp);
        
        snprintf(tmp, 256, "      \"id\": %d,\n", block->id);
        json_append(&buf, tmp);
        
        snprintf(tmp, 256, "      \"type\": \"%s\",\n", info ? info->name : "unknown");
        json_append(&buf, tmp);
        
        snprintf(tmp, 256, "      \"x\": %.1f,\n", block->x);
        json_append(&buf, tmp);
        
        snprintf(tmp, 256, "      \"y\": %.1f\n", block->y);
        json_append(&buf, tmp);
        
        json_append(&buf, i < ws->block_count - 1 ? "    },\n" : "    }\n");
    }
    json_append(&buf, "  ],\n");
    
    // 保存连接
    json_append(&buf, "  \"connections\": [\n");
    for (int i = 0; i < ws->connection_count; i++) {
        BlockConnection* conn = &ws->connections[i];
        char tmp[128];
        snprintf(tmp, 128, "    {\"from\": %d, \"to\": %d}%s\n",
            conn->from ? conn->from->owner->id : 0,
            conn->to ? conn->to->owner->id : 0,
            i < ws->connection_count - 1 ? "," : "");
        json_append(&buf, tmp);
    }
    json_append(&buf, "  ]\n");
    
    json_append(&buf, "}\n");
    
    return buf.buffer;
}

int serializer_load_from_string(BlockWorkspace* ws, const char* json_str) {
    // 简化的 JSON 解析
    // 完整实现需要完整的 JSON 解析器
    
    workspace_clear(ws);
    
    // 查找 "blocks" 数组
    const char* blocks_start = strstr(json_str, "\"blocks\"");
    if (!blocks_start) return 0;
    
    // 简化解析 - 只提取基本信息
    // 实际项目中应使用 cJSON 或类似库
    
    // TODO: 实现完整的 JSON 解析
    
    return 1;
}