#include "../include/metadata.h"

#include <iostream>

namespace feather {

void Metadata::serialize(std::ostream& os) const {

os.write(reinterpret_cast<const char*>(&timestamp), 8);

os.write(reinterpret_cast<const char*>(&importance), 4);

uint8_t type_val = static_cast<uint8_t>(type);

os.write(reinterpret_cast<const char*>(&type_val), 1);

uint16_t source_len = static_cast<uint16_t>(source.size());

os.write(reinterpret_cast<const char*>(&source_len), 2);

os.write(source.data(), source_len);

uint32_t content_len = static_cast<uint32_t>(content.size());

os.write(reinterpret_cast<const char*>(&content_len), 4);

os.write(content.data(), content_len);

uint16_t tags_len = static_cast<uint16_t>(tags_json.size());

os.write(reinterpret_cast<const char*>(&tags_len), 2);

os.write(tags_json.data(), tags_len);

// Phase 3: Write 0 links (legacy slot — edges field replaces this in v5)

// We write links_count=0 so v3/v4 readers see no plain links and don't crash.

uint16_t links_count = 0;

os.write(reinterpret_cast<const char*>(&links_count), 2);

os.write(reinterpret_cast<const char*>(&recall_count), 4);

os.write(reinterpret_cast<const char*>(&last_recalled_at), 8);

// Phase 4: namespace_id, entity_id, attributes

uint16_t ns_len = static_cast<uint16_t>(namespace_id.size());

os.write(reinterpret_cast<const char*>(&ns_len), 2);

os.write(namespace_id.data(), ns_len);

uint16_t eid_len = static_cast<uint16_t>(entity_id.size());

os.write(reinterpret_cast<const char*>(&eid_len), 2);

os.write(entity_id.data(), eid_len);

uint16_t attr_count = static_cast<uint16_t>(attributes.size());

os.write(reinterpret_cast<const char*>(&attr_count), 2);

for (const auto& [key, val] : attributes) {

uint16_t key_len = static_cast<uint16_t>(key.size());

os.write(reinterpret_cast<const char*>(&key_len), 2);

os.write(key.data(), key_len);

uint32_t val_len = static_cast<uint32_t>(val.size());

os.write(reinterpret_cast<const char*>(&val_len), 4);

os.write(val.data(), val_len);

}

// Phase 5: typed, weighted edges

uint16_t edge_count = static_cast<uint16_t>(edges.size());

os.write(reinterpret_cast<const char*>(&edge_count), 2);

for (const auto& e : edges) {

os.write(reinterpret_cast<const char*>(&e.target_id), 8);

uint8_t rt_len = static_cast<uint8_t>(std::min(e.rel_type.size(), size_t(255)));

os.write(reinterpret_cast<const char*>(&rt_len), 1);

os.write(e.rel_type.data(), rt_len);

os.write(reinterpret_cast<const char*>(&e.weight), 4);

}

// Phase 6: ttl + confidence

os.write(reinterpret_cast<const char*>(&ttl), 8);

os.write(reinterpret_cast<const char*>(&confidence), 4);

}

Metadata Metadata::deserialize(std::istream& is) {

Metadata m;

is.read(reinterpret_cast<char*>(&m.timestamp), 8);

is.read(reinterpret_cast<char*>(&m.importance), 4);

uint8_t type_val;

is.read(reinterpret_cast<char*>(&type_val), 1);

m.type = static_cast<ContextType>(type_val);

uint16_t source_len;

is.read(reinterpret_cast<char*>(&source_len), 2);

m.source.resize(source_len);

is.read(&m.source[0], source_len);

uint32_t content_len;

is.read(reinterpret_cast<char*>(&content_len), 4);

m.content.resize(content_len);

is.read(&m.content[0], content_len);

uint16_t tags_len;

is.read(reinterpret_cast<char*>(&tags_len), 2);

m.tags_json.resize(tags_len);

is.read(&m.tags_json[0], tags_len);

// Phase 3: legacy links slot (v3/v4 used this; v5 writes 0 here but reads edges below)

uint16_t links_count = 0;

if (!is.read(reinterpret_cast<char*>(&links_count), 2)) return m;

if (links_count > 0) {

// Old v3/v4 plain link IDs — promote to edges with default type/weight

for (uint16_t i = 0; i < links_count; ++i) {

uint64_t target;

is.read(reinterpret_cast<char*>(&target), 8);

m.edges.push_back({target, "related_to", 1.0f});

}

}

is.read(reinterpret_cast<char*>(&m.recall_count), 4);

is.read(reinterpret_cast<char*>(&m.last_recalled_at), 8);

// Phase 4: namespace_id, entity_id, attributes

uint16_t ns_len = 0;

if (!is.read(reinterpret_cast<char*>(&ns_len), 2)) return m;

m.namespace_id.resize(ns_len);

if (ns_len > 0) is.read(&m.namespace_id[0], ns_len);

uint16_t eid_len = 0;

is.read(reinterpret_cast<char*>(&eid_len), 2);

m.entity_id.resize(eid_len);

if (eid_len > 0) is.read(&m.entity_id[0], eid_len);

uint16_t attr_count = 0;

is.read(reinterpret_cast<char*>(&attr_count), 2);

for (uint16_t i = 0; i < attr_count; ++i) {

uint16_t key_len = 0;

is.read(reinterpret_cast<char*>(&key_len), 2);

std::string key(key_len, '\0');

if (key_len > 0) is.read(&key[0], key_len);

uint32_t val_len = 0;

is.read(reinterpret_cast<char*>(&val_len), 4);

std::string val(val_len, '\0');

if (val_len > 0) is.read(&val[0], val_len);

m.attributes[key] = val;

}

// Phase 5: typed, weighted edges

uint16_t edge_count = 0;

if (!is.read(reinterpret_cast<char*>(&edge_count), 2)) return m;

for (uint16_t i = 0; i < edge_count; ++i) {

Edge e;

is.read(reinterpret_cast<char*>(&e.target_id), 8);

uint8_t rt_len = 0;

is.read(reinterpret_cast<char*>(&rt_len), 1);

e.rel_type.resize(rt_len);

if (rt_len > 0) is.read(&e.rel_type[0], rt_len);

is.read(reinterpret_cast<char*>(&e.weight), 4);

m.edges.push_back(std::move(e));

}

// Phase 6: ttl + confidence (guarded — v5 files default to 0 / 1.0)

int64_t ttl_val = 0;

if (!is.read(reinterpret_cast<char*>(&ttl_val), 8)) return m;

m.ttl = ttl_val;

float conf_val = 1.0f;

if (!is.read(reinterpret_cast<char*>(&conf_val), 4)) return m;

m.confidence = conf_val;

return m;

}

} // namespace feather