using Elements;
using Elements.Serialization.JSON;

// ===== 序列化 =====

// 方式一：输出到文件（推荐，避免大对象堆上的字符串分配）
var model = new Model();
// ... 添加元素 ...
model.ToJson("output.json");

// 方式二：输出到内存流
using var stream = new MemoryStream();
model.ToJson(stream, indent: true);

// 方式三：输出为字符串（小模型可用）
string json = model.ToJson(indent: false);

// ===== 反序列化 =====

// 方式一：从字符串反序列化（带错误收集）
Model loaded = Model.FromJson(json, out List<string> errors);
if (errors.Any())
{
    foreach (var err in errors)
        Console.WriteLine($"反序列化警告: {err}");
}

// 方式二：忽略错误
Model loaded2 = Model.FromJson(json);

// 方式三：强制刷新类型缓存（动态加载了自定义元素类型时）
Model loaded3 = Model.FromJson(json, forceTypeReload: true);

// JsonInheritanceConverter 是全局注册的自定义转换器
// 所有 Element 派生类通过 [JsonConverter] 特性标记：
[JsonConverter(typeof(JsonInheritanceConverter), "discriminator")]
public abstract class Element { ... }

// 源码中的核心逻辑（简化）
private static string GetDiscriminatorName(object value)
{
    var t = value.GetType();
    // 泛型类型特殊处理：ElementProxy<Beam> → "Elements.ElementProxy<Elements.Beam>"
    if (t.IsGenericType)
        return $"{t.FullName.Split('`').First()}<{string.Join(",", t.GenericTypeArguments.Select(a => a.FullName))}>";
    else
        return t.FullName.Split('`').First();
}

// 反序列化流程
// 1. 读取 discriminator → "Elements.Wall"
// 2. 在 TypeCache 中查找 → typeof(Wall)
// 3. 如果找不到类型（例如用户自定义类型尚未加载），回退策略：
//    - 有 Representation 属性 → 反序列化为 GeometricElement
//    - 有 Id 属性 → 反序列化为 Element
//    - 都不满足 → 返回 objectType

// 缓存初始化——遍历 AppDomain 中所有已加载程序集
private static Dictionary<string, Type> BuildAppDomainTypeCache(out List<string> failedAssemblyErrors)
{
    var typeCache = new Dictionary<string, Type>();
    foreach (var assembly in AppDomain.CurrentDomain.GetAssemblies())
    {
        foreach (var t in assembly.GetTypes())
        {
            // 筛选规则：public class + 标记了 [JsonConverter(typeof(JsonInheritanceConverter))]
            if (t.IsPublic && t.IsClass &&
                t.GetCustomAttribute<JsonConverterAttribute>()?.ConverterType == typeof(JsonInheritanceConverter))
            {
                typeCache[t.FullName] = t;
            }
        }
    }
    return typeCache;
}

// 序列化时：Wall.Material 如果是 Material 元素，则只写 Guid
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
    var element = value as Element;
    // 只有顶层路径（Elements.xxxxx）才展开完整内容
    // 非顶层路径下的 Element 只序列化 Id
    if (element != null && !PathIsTopLevel(writer.Path, "Elements"))
        writer.WriteValue(element.Id);
    else
    {
        // 展开完整 JSON 对象，注入 discriminator
        var jObject = JObject.FromObject(value, serializer);
        jObject.AddFirst(new JProperty(_discriminator, GetDiscriminatorName(value)));
        writer.WriteToken(jObject.CreateReader());
    }
}

[JsonExtensionData]
public Dictionary<string, object> AdditionalProperties { get; set; }

using Elements.Serialization.glTF;

// ===== GLB 导出（二进制 glTF，推荐） =====

// 方式一：导出到文件
model.ToGlTF("model.glb");  // 默认 useBinarySerialization = true

// 方式二：导出到字节数组（适合 Web API 返回）
byte[] glbBytes = model.ToGlTF(drawEdges: false, mergeVertices: false);

// 方式三：导出到流
using var stream = new MemoryStream();
model.ToGlTF(stream, drawEdges: true);

// ===== glTF 导出（JSON + 分离的 .bin 文件） =====

model.ToGlTF("model.gltf", useBinarySerialization: false);

// ===== Base64 编码（适合嵌入 HTML 的 data URI） =====
string b64 = model.ToBase64String();
// <img src="data:model/gltf-binary;base64,{b64}" />

// 关键数据结构（概念表示）
public class GraphicsBuffers
{
    public List<byte> Vertices;   // float[] 顶点坐标（交织存储）
    public List<byte> Normals;    // float[] 法线向量
    public List<byte> Indices;    // ushort[] 三角形索引
    public List<byte> UVs;        // float[] 纹理坐标
    public List<byte> Colors;     // float[] 顶点颜色

    public double[] VMin, VMax;   // 顶点包围盒（用于 glTF accessor）
    public double[] NMin, NMax;   // 法线包围盒
    public int IMin, IMax;        // 索引范围
}

// 映射规则
gltfMaterial.PbrMetallicRoughness = new MaterialPbrMetallicRoughness
{
    BaseColorFactor = material.Color.ToArray(true),   // RGBA → float[4]
    RoughnessFactor = 1.0f - material.GlossinessFactor, // 光泽度 → 粗糙度
    MetallicFactor = 0                                 // 建筑材质默认非金属
};

// 支持的 glTF 扩展
// KHR_materials_specular  — 镜面反射（从 Material.SpecularFactor）
// KHR_materials_ior       — 折射率
// KHR_materials_unlit     — 无光照材质（Material.Unlit）
// HYPAR_materials_edge_settings — Hypar 自定义边缘显示
// HYPAR_draw_in_front     — 始终在最前渲染

using Elements.Serialization.IFC;

// ===== 写出 IFC =====

// 方式一：导出到文件
model.ToIFC("building.ifc");

// 方式二：导出到流
using var stream = new MemoryStream();
model.ToIFC(stream, leaveOpen: true);

// ===== 读取 IFC =====

// 读取 IFC STEP 文件（可指定要转换的元素 Id 集合）
Model importedModel = IFCModelExtensions.FromIFC("source.ifc",
    out List<string> constructionErrors,
    idsToConvert: new[] { "IFCGuid-1", "IFCGuid-2" });

foreach (var err in constructionErrors)
    Console.WriteLine($"IFC 导入警告: {err}");

// 源码简化：空间层次自动创建
private static Document CreateIfcDocument(this Model model)
{
    var ifc = new Document(...);

    // 创建 Site → Building → Storey 标准三级结构
    var site = new IfcSite(...);
    var building = new IfcBuilding(...);
    var storey = new IfcBuildingStorey(...);

    // 将所有产品分配到 Storey 下
    var spatialRel = new IfcRelContainedInSpatialStructure(products, storey);

    return ifc;
}

// 概念代码：Extrude → IfcExtrudedAreaSolid
var profile = extrude.Profile;
var position = new IfcAxis2Placement3D(...);
var profileDef = new IfcArbitraryClosedProfileDef(
    IfcProfileTypeEnum.AREA, null, position, profile.Perimeter.ToIfcPolyline());

var solid = new IfcExtrudedAreaSolid(
    profileDef,
    position,
    extrude.Direction.ToIfcDirection(),
    extrude.Height);

// 附加材质关联
var styledItem = new IfcStyledItem(solid,
    new[] { styleAssignments[material.Id] }, material.Name);

var representation = new IfcProductDefinitionShape(
    null, null, new[] { new IfcShapeRepresentation(..., "Body", "SweptSolid", new[] { styledItem }) });

// IFC 读取的核心解析过程
public static Model FromIFC(string path, out List<string> constructionErrors, IList<string> idsToConvert = null)
{
    var modelProvider = new FromIfcModelProvider(path, idsToConvert: idsToConvert);
    constructionErrors = modelProvider.GetConstructionErrors();
    return modelProvider.Model;
}

using Elements.Serialization.DXF;

// 创建渲染器
var renderer = new ModelToDxf();

// 可选：设置图层映射配置
renderer.SetMappingConfiguration(new MappingConfiguration
{
    // 自定义图层名、线宽、颜色映射
});

// 渲染到流
using var dxfStream = renderer.Render(model);

// 保存到文件
using var fileStream = File.Create("plan.dxf");
dxfStream.CopyTo(fileStream);

private Dictionary<Type, IRenderDxf> _dxfCreators = new Dictionary<Type, IRenderDxf>
{
    { typeof(ContentElement), new ContentElementToDXF() },
    { typeof(ElementInstance), new ElementInstanceToDXF() }
};

// 概念代码：几何兜底
public class GeometricElementToDxf : IRenderDxf
{
    public void TryAddDxfEntity(DxfFile doc, GeometricElement element, DxfRenderContext context)
    {
        // 将元素三角剖分为网格
        var mesh = element.ToMesh();

        // 将三角形边提取为 DXF LINE 图元
        foreach (var triangle in mesh.Triangles)
        {
            // 每条边生成一条 DXF Line
            doc.Entities.Add(new DxfLine(triangle.Vertices[0].Position,
                                          triangle.Vertices[1].Position));
            // ... 其余两条边
        }
    }
}

using Elements.Serialization.SVG;

// 方式一：静态方法，一步生成并保存
SvgSection.CreateAndSavePlanFromModels(
    models: new[] { model },
    elevation: 1.2,                       // 剖切标高（单位：米）
    frontContext: new SvgContext           // 截面样式
    {
        Fill = new SvgColourServer(Color.Black),
        StrokeWidth = new SvgUnit(SvgUnitType.User, 0.01f)
    },
    backContext: new SvgContext            // 后景样式
    {
        Stroke = new SvgColourServer(Color.Gray),
        StrokeWidth = new SvgUnit(SvgUnitType.User, 0.005f)
    },
    path: "floor_plan.svg",
    showGrid: true,                       // 显示轴网
    planRotation: PlanRotation.LongestGridHorizontal  // 自动旋转对齐
);

// 方式二：实例化后自定义
var section = new SvgSection(new[] { model }, elevation: 1.2)
{
    FrontContext = new SvgContext { Fill = new SvgColourServer(Color.Red) },
    BackContext = new SvgContext { Stroke = new SvgColourServer(Color.Blue) },
    ShowGrid = true,
    GridHeadExtension = 2.0,
    GridHeadRadius = 0.5,
    PlanRotation = PlanRotation.None,
    PlanRotationDegrees = 0
};

// 注册元素绘制事件（自定义渲染）
section.OnElementDrawing += (sender, args) =>
{
    if (args.Element is Wall)
    {
        // 自定义墙的 SVG 绘制逻辑
        args.IsProcessed = true;
        args.CreationSequence = ElementSerializationEventArgs.CreationSequences.Immediately;
        args.SvgElements.Add(new SvgCircle { ... });
    }
};

section.SaveAsSvg("custom_plan.svg");
section.SaveAsPdf("custom_plan.pdf", new PdfSaveOptions
{
    PageWidth = 841,   // A4 横向
    PageHeight = 594,
    Margin = 20
});

// 源码简化：剖切 = 平面求交
var plane = new Plane(new Vector3(0, 0, elevation), Vector3.ZAxis);

model.Intersect(plane,
    out Dictionary<Guid, List<Polygon>> intersecting,   // Front：截面上的多边形
    out Dictionary<Guid, List<Polygon>> back,           // Back：平面后的多边形投影
    out Dictionary<Guid, List<Line>> lines);            // 线段（轴网等）

// 将 Polygon 转换为 SVG <path> 元素
// Front 使用 FrontContext（实心填充 + 粗线）
// Back 使用 BackContext（仅有描边 + 细线）

using Elements.Serialization.SVG;

// 从元素的 BRep 面创建立面图
var solid = element.GetFinalSolid();
var face = solid.Faces.First(f => /* 选出目标面 */);

var elevation = new SvgFaceElevation(face, up: Vector3.ZAxis)
{
    ElementLinesContext = new SvgContext
    {
        Stroke = new SvgColourServer(Color.Black),
        StrokeWidth = new SvgUnit(SvgUnitType.User, 0.01f)
    },
    DimensionLinesContext = new SvgContext
    {
        Stroke = new SvgColourServer(Color.DarkBlue),
        StrokeWidth = new SvgUnit(SvgUnitType.User, 0.005f)
    },
    PlanRotationDegrees = 0
};

elevation.SaveAsSvg("elevation.svg");
elevation.SaveAsPdf("elevation.pdf", new PdfSaveOptions
{
    PageWidth = 594,
    PageHeight = 841,
    Margin = 20
});

public class SvgContext
{
    public SvgColourServer Fill { get; set; }       // 填充色
    public SvgColourServer Stroke { get; set; }     // 描边色
    public SvgUnit StrokeWidth { get; set; }         // 描边宽度
    public SvgStrokeLineCap StrokeLineCap { get; set; } // 端点样式
    public SvgUnitCollection StrokeDashArray { get; set; } // 虚线样式
}

// 截面：黑色填充
var frontContext = new SvgContext
{
    Fill = new SvgColourServer(Color.Black),
    StrokeWidth = new SvgUnit(SvgUnitType.User, 0.01f)
};

// 后景：灰色虚线
var backContext = new SvgContext
{
    Stroke = new SvgColourServer(Color.Gray),
    StrokeWidth = new SvgUnit(SvgUnitType.User, 0.005f),
    StrokeDashArray = new SvgUnitCollection
    {
        new SvgUnit(SvgUnitType.User, 0.1f),
        new SvgUnit(SvgUnitType.User, 0.05f)
    }
};

// 轴网：长虚线
var gridContext = new SvgContext
{
    Stroke = new SvgColourServer(Color.Black),
    StrokeWidth = new SvgUnit(SvgUnitType.User, 0.01f),
    StrokeDashArray = new SvgUnitCollection
    {
        new SvgUnit(SvgUnitType.User, 0.3f),
        new SvgUnit(SvgUnitType.User, 0.025f),
        new SvgUnit(SvgUnitType.User, 0.05f),
        new SvgUnit(SvgUnitType.User, 0.025f)
    }
};

public class PdfSaveOptions
{
    public float PageWidth { get; set; } = 841;   // 默认 A4 横向
    public float PageHeight { get; set; } = 594;
    public float Margin { get; set; } = 20;
}

using System;
using System.Collections.Generic;
using System.Drawing;
using System.IO;
using System.Linq;
using Elements;
using Elements.Geometry;
using Elements.Geometry.Solids;
using Elements.Geometry.Profiles;
using Elements.Serialization.JSON;
using Elements.Serialization.glTF;
using Elements.Serialization.IFC;
using Elements.Serialization.DXF;
using Elements.Serialization.SVG;

// ========== 步骤 1：创建模型 ==========

var model = new Model();

// 添加材质
var concreteMaterial = new Material("混凝土", new Color(0.7, 0.7, 0.7, 1.0));
var steelMaterial = new Material("钢材", new Color(0.5, 0.5, 0.6, 1.0));
model.AddElements(concreteMaterial, steelMaterial);

// 创建外墙（Extrude 表示）
var wallLine = new Line(new Vector3(0, 0, 0), new Vector3(10, 0, 0));
var wall = new StandardWall(
    wallLine,
    0.2,   // 厚度
    3.0,   // 高度
    concreteMaterial,
    transform: new Transform());
wall.Name = "外墙 A";
model.AddElement(wall);

// 创建柱（通过 Profile + Extrude）
var columnProfile = Polygon.Rectangle(0.3, 0.3);
var column = new Column(
    new Vector3(5, 0, 0),
    3.0,
    columnProfile,
    concreteMaterial,
    transform: new Transform());
column.Name = "柱 C1";
model.AddElement(column);

// 创建梁
var beamLine = new Line(new Vector3(0, 3, 3.0), new Vector3(10, 3, 3.0));
var beam = new Beam(beamLine, profile: Polygon.Rectangle(0.2, 0.4),
    material: steelMaterial,
    transform: new Transform());
beam.Name = "梁 B1";
model.AddElement(beam);

// 创建楼板
var floorOutline = Polygon.Rectangle(10, 5);
var floor = new Floor(floorOutline, 0.15, new Transform(0, 0, 0),
    material: concreteMaterial);
floor.Name = "楼板 F1";
model.AddElement(floor);

// 创建空间
var spaceBoundary = Polygon.Rectangle(9, 4);
var space = new Space(spaceBoundary, 3.0, 0.0,
    new Transform(new Vector3(0.5, 0.5, 0.15)));
space.Name = "房间 101";
model.AddElement(space);

// ========== 步骤 2：更新几何表示 ==========

model.UpdateBoundsAndComputedSolids();

// ========== 步骤 3：JSON 序列化 ==========

// 格式化输出，适合 Git 版本控制
model.ToJson("complete_model.json", indent: true);

// 验证：反序列化回来
var reloaded = Model.FromJson(File.ReadAllText("complete_model.json"), out var jsonErrors);
Console.WriteLine($"JSON 反序列化: {reloaded.Elements.Count} 个元素, {jsonErrors.Count} 个错误");

// ========== 步骤 4：glTF/GLB 导出 ==========

// GLB 二进制（Web 3D 查看器、游戏引擎）
model.ToGlTF("complete_model.glb");
Console.WriteLine("GLB 导出完成");

// 带边缘线的高质量 GLB
model.ToGlTF("complete_model_edges.glb", drawEdges: true);

// 字节数组（Web API 返回）
byte[] glbBytes = model.ToGlTF();
File.WriteAllBytes("complete_model_api.glb", glbBytes);

// ========== 步骤 5：IFC 导出与导入 ==========

// 导出为 IFC STEP 文件
model.ToIFC("complete_model.ifc");
Console.WriteLine("IFC 导出完成");

// 从 IFC 重新导入
var ifcModel = IFCModelExtensions.FromIFC("complete_model.ifc", out var ifcErrors);
Console.WriteLine($"IFC 导入: {ifcModel.Elements.Count} 个元素, {ifcErrors.Count} 个警告");

// ========== 步骤 6：DXF 导出 ==========

var dxfRenderer = new ModelToDxf();
using (var dxfStream = dxfRenderer.Render(model))
using (var fileStream = File.Create("complete_model.dxf"))
{
    dxfStream.CopyTo(fileStream);
}
Console.WriteLine("DXF 导出完成");

// ========== 步骤 7：SVG/PDF 平面图 ==========

var frontContext = new SvgContext
{
    Fill = new SvgColourServer(Color.Black),
    StrokeWidth = new SvgUnit(SvgUnitType.User, 0.01f)
};
var backContext = new SvgContext
{
    Stroke = new SvgColourServer(Color.DarkGray),
    StrokeWidth = new SvgUnit(SvgUnitType.User, 0.005f)
};

// 在 1.5m 标高处剖切生成平面图
SvgSection.CreateAndSavePlanFromModels(
    models: new[] { model },
    elevation: 1.5,
    frontContext: frontContext,
    backContext: backContext,
    path: "complete_plan.svg",
    showGrid: false,
    planRotation: PlanRotation.None);

// 同时导出 PDF
var section = new SvgSection(new[] { model }, elevation: 1.5)
{
    FrontContext = frontContext,
    BackContext = backContext,
    ShowGrid = false
};
section.SaveAsPdf("complete_plan.pdf", new PdfSaveOptions
{
    PageWidth = 841,
    PageHeight = 594,
    Margin = 30
});
Console.WriteLine("SVG 平面图 / PDF 导出完成");

// ========== 步骤 8：输出总结 ==========

Console.WriteLine("\n=== 导出完成 ===");
Console.WriteLine($"  JSON           : complete_model.json");
Console.WriteLine($"  GLB            : complete_model.glb / complete_model_edges.glb");
Console.WriteLine($"  IFC            : complete_model.ifc (可导入 Revit/Archicad)");
Console.WriteLine($"  DXF            : complete_model.dxf (可导入 AutoCAD)");
Console.WriteLine($"  SVG            : complete_plan.svg");
Console.WriteLine($"  PDF            : complete_plan.pdf");