// tongwen_bracket_translate.cs
// 需要引用 TongWen 库和 AutoCAD .NET API（或 Teigha/ODA）
// 本示例展示核心调用逻辑

using TongWen.Translation;
using TongWen.CadIntegration;

public class BracketTranslator
{
    public void TranslateDrawing(string dwgPath, string outputPath)
    {
        // 1. 加载 AutoCAD 图纸
        using var cadDoc = CadDocument.Open(dwgPath);

        // 2. 配置翻译引擎（中文 → 英文）
        var engine = new TranslationEngine(
            sourceLang: "zh-CN",
            targetLang: "en-US",
            glossaryPath: "cad_glossary.json"  // CAD 术语词典
        );

        // 3. 遍历所有文本实体
        foreach (var text in cadDoc.GetAllTextEntities())
        {
            // 过滤掉纯数字和符号（无需翻译）
            if (string.IsNullOrWhiteSpace(text.Content) ||
                text.Content.All(c => char.IsDigit(c) || char.IsPunctuation(c)))
                continue;

            // 翻译并替换
            var translated = engine.Translate(text.Content);
            text.Content = translated;

            // 保留原始文字样式、对齐方式、图层
            // TongWen 自动处理多行文本（MText）的格式保留
        }

        // 4. 翻译属性块（Block Attributes）中的文字
        foreach (var block in cadDoc.GetAllBlockReferences())
        {
            foreach (var attr in block.GetAttributes())
            {
                if (!string.IsNullOrWhiteSpace(attr.TextString))
                {
                    attr.TextString = engine.Translate(attr.TextString);
                }
            }
        }

        // 5. 翻译尺寸标注文字（Dimensions）
        foreach (var dim in cadDoc.GetAllDimensions())
        {
            if (!string.IsNullOrWhiteSpace(dim.DimensionText))
            {
                dim.DimensionText = engine.Translate(dim.DimensionText);
            }
        }

        // 6. 保存翻译后的图纸
        cadDoc.SaveAs(outputPath);

        // 7. 生成翻译报告
        engine.GenerateReport("translation_report.html");
    }
}

// 调用
var translator = new BracketTranslator();
translator.TranslateDrawing("bracket_drawing.dwg", "bracket_drawing_en.dwg");

// GisConversionController.cs
// Furion 框架 + GDAL 集成

using Furion;
using Furion.DependencyInjection;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using System.Diagnostics;
using System.IO.Compression;

namespace GisApi.Controllers;

[ApiController]
[Route("api/gis")]
public class GisConversionController : ControllerBase
{
    private readonly ILogger<GisConversionController> _logger;

    public GisConversionController(ILogger<GisConversionController> logger)
    {
        _logger = logger;
    }

    /// <summary>
    /// 上传 Shapefile 压缩包，转换为 GeoJSON 返回
    /// </summary>
    [HttpPost("shp-to-geojson")]
    public async Task<IActionResult> ConvertShapefileToGeoJson(IFormFile file)
    {
        // 1. 参数校验
        if (file == null || file.Length == 0)
            return BadRequest("请上传文件");

        if (!file.FileName.EndsWith(".zip", StringComparison.OrdinalIgnoreCase))
            return BadRequest("请上传 .zip 格式的 Shapefile 压缩包");

        var tempDir = Path.Combine(Path.GetTempPath(), $"gis_{Guid.NewGuid():N}");
        var outputPath = Path.Combine(tempDir, "output.geojson");

        try
        {
            // 2. 解压上传文件
            Directory.CreateDirectory(tempDir);
            var zipPath = Path.Combine(tempDir, file.FileName);

            await using (var stream = new FileStream(zipPath, FileMode.Create))
            {
                await file.CopyToAsync(stream);
            }

            ZipFile.ExtractToDirectory(zipPath, tempDir);

            // 3. 查找 .shp 文件
            var shpFile = Directory.GetFiles(tempDir, "*.shp").FirstOrDefault();
            if (shpFile == null)
                return BadRequest("压缩包中未找到 .shp 文件");

            // 4. 调用 GDAL ogr2ogr 进行格式转换
            var processInfo = new ProcessStartInfo
            {
                FileName = "ogr2ogr",
                Arguments = $"-f GeoJSON \"{outputPath}\" \"{shpFile}\" -t_srs EPSG:4326",
                RedirectStandardOutput = true,
                RedirectStandardError = true,
                UseShellExecute = false,
                CreateNoWindow = true
            };

            using var process = Process.Start(processInfo);
            if (process == null)
                return StatusCode(500, "无法启动 GDAL 进程");

            var stderr = await process.StandardError.ReadToEndAsync();
            await process.WaitForExitAsync();

            if (process.ExitCode != 0)
            {
                _logger.LogError("GDAL 转换失败: {Error}", stderr);
                return StatusCode(500, $"GDAL 转换失败: {stderr}");
            }

            // 5. 读取生成的 GeoJSON 并返回
            if (!System.IO.File.Exists(outputPath))
                return StatusCode(500, "GeoJSON 文件未生成");

            var geoJsonContent = await System.IO.File.ReadAllTextAsync(outputPath);
            return Content(geoJsonContent, "application/json", System.Text.Encoding.UTF8);
        }
        finally
        {
            // 6. 清理临时文件
            if (Directory.Exists(tempDir))
            {
                try { Directory.Delete(tempDir, true); } catch { /* 清理失败不阻塞响应 */ }
            }
        }
    }

    /// <summary>
    /// 查询 GeoJSON 的基本信息（调用 ogrinfo）
    /// </summary>
    [HttpPost("geojson-info")]
    public async Task<IActionResult> GetGeoJsonInfo(IFormFile file)
    {
        if (file == null || file.Length == 0)
            return BadRequest("请上传文件");

        var tempFile = Path.GetTempFileName();
        try
        {
            await using (var stream = new FileStream(tempFile, FileMode.Create))
            {
                await file.CopyToAsync(stream);
            }

            var processInfo = new ProcessStartInfo
            {
                FileName = "ogrinfo",
                Arguments = $"-so -json \"{tempFile}\"",
                RedirectStandardOutput = true,
                RedirectStandardError = true,
                UseShellExecute = false,
                CreateNoWindow = true
            };

            using var process = Process.Start(processInfo);
            if (process == null)
                return StatusCode(500, "无法启动 GDAL 进程");

            var stdout = await process.StandardOutput.ReadToEndAsync();
            var stderr = await process.StandardError.ReadToEndAsync();
            await process.WaitForExitAsync();

            if (process.ExitCode != 0)
                return StatusCode(500, $"ogrinfo 执行失败: {stderr}");

            return Content(stdout, "application/json", System.Text.Encoding.UTF8);
        }
        finally
        {
            if (System.IO.File.Exists(tempFile))
                System.IO.File.Delete(tempFile);
        }
    }
}

// PoiService.cs — 基于 SqlSugar ORM 的数据服务
// Furion 框架下的服务层

using Furion.DependencyInjection;
using SqlSugar;
using GisApi.Models;

namespace GisApi.Services;

public class PoiService : ITransient
{
    private readonly ISqlSugarClient _db;

    public PoiService(ISqlSugarClient db)
    {
        _db = db;
    }

    /// <summary>
    /// 分页查询 POI 列表，支持按分类和密度筛选
    /// </summary>
    public async Task<SqlSugarPagedList<PoiDto>> QueryPagedAsync(PoiQueryInput input)
    {
        var query = _db.Queryable<Poi>();

        // 分类筛选
        if (!string.IsNullOrWhiteSpace(input.Category))
        {
            query = query.Where(p => p.Category == input.Category);
        }

        // 密度筛选
        if (input.MinNearbyCount.HasValue)
        {
            query = query.Where(p => p.NearbyCount >= input.MinNearbyCount.Value);
        }

        if (input.MaxNearbyCount.HasValue)
        {
            query = query.Where(p => p.NearbyCount <= input.MaxNearbyCount.Value);
        }

        // 关键词搜索
        if (!string.IsNullOrWhiteSpace(input.Keyword))
        {
            query = query.Where(p => p.Name.Contains(input.Keyword) ||
                                     p.Address.Contains(input.Keyword));
        }

        // 排序（默认按密度降序）
        var orderField = input.OrderBy switch
        {
            "name" => nameof(Poi.Name),
            "category" => nameof(Poi.Category),
            "nearby_count" => nameof(Poi.NearbyCount),
            _ => nameof(Poi.NearbyCount)
        };

        query = input.OrderDesc
            ? query.OrderByDescending(orderField)
            : query.OrderBy(orderField);

        // 分页
        var total = 0;
        var list = await query
            .Select(p => new PoiDto
            {
                Id = p.Id,
                Name = p.Name,
                Category = p.Category,
                Address = p.Address,
                NearbyCount = p.NearbyCount,
                Longitude = p.Longitude,
                Latitude = p.Latitude
            })
            .ToPageListAsync(input.Page, input.PageSize, total);

        return new SqlSugarPagedList<PoiDto>
        {
            Items = list,
            Total = total,
            Page = input.Page,
            PageSize = input.PageSize
        };
    }

    /// <summary>
    /// 按分类统计 POI 数量和平均密度
    /// </summary>
    public async Task<List<CategoryStatDto>> GetCategoryStatsAsync()
    {
        return await _db.Queryable<Poi>()
            .GroupBy(p => p.Category)
            .Select(g => new CategoryStatDto
            {
                Category = g.Category,
                Count = SqlFunc.AggregateCount(g.Id),
                AvgDensity = SqlFunc.AggregateAvg(g.NearbyCount),
                MaxDensity = SqlFunc.AggregateMax(g.NearbyCount)
            })
            .OrderByDescending(s => s.Count)
            .ToListAsync();
    }
}

// PoiExportService.cs — 基于 NPOI 的 Excel 导出
// 将 POI 查询结果导出为 .xlsx 文件

using Furion.DependencyInjection;
using NPOI.SS.UserModel;
using NPOI.XSSF.UserModel;
using NPOI.SS.Util;

namespace GisApi.Services;

public class PoiExportService : ITransient
{
    private readonly PoiService _poiService;

    public PoiExportService(PoiService poiService)
    {
        _poiService = poiService;
    }

    /// <summary>
    /// 导出 POI 数据为 Excel 文件并返回文件路径
    /// </summary>
    public async Task<string> ExportToExcelAsync(PoiQueryInput input)
    {
        // 查询数据（不分页，全量导出）
        input.Page = 1;
        input.PageSize = 100000;
        var result = await _poiService.QueryPagedAsync(input);

        // 创建 Excel 工作簿
        var workbook = new XSSFWorkbook();
        var sheet = workbook.CreateSheet("POI数据");

        // ====== 标题行样式 ======
        var headerStyle = workbook.CreateCellStyle();
        var headerFont = workbook.CreateFont();
        headerFont.IsBold = true;
        headerFont.FontHeightInPoints = 12;
        headerStyle.SetFont(headerFont);
        headerStyle.FillForegroundColor = NPOI.HSSF.Util.HSSFColor.Grey25Percent.Index;
        headerStyle.FillPattern = FillPattern.SolidForeground;
        headerStyle.BorderBottom = BorderStyle.Medium;
        headerStyle.Alignment = HorizontalAlignment.Center;

        // ====== 数据行样式 ======
        var dataStyle = workbook.CreateCellStyle();
        dataStyle.BorderBottom = BorderStyle.Thin;
        dataStyle.Alignment = HorizontalAlignment.Left;

        // 密度高亮样式
        var highDensityStyle = workbook.CreateCellStyle();
        highDensityStyle.CloneStyleFrom(dataStyle);
        var highFont = workbook.CreateFont();
        highFont.Color = NPOI.HSSF.Util.HSSFColor.Red.Index;
        highFont.IsBold = true;
        highDensityStyle.SetFont(highFont);

        // ====== 表头 ======
        var headers = new[] { "序号", "名称", "分类", "地址", "500m内POI数", "经度", "纬度" };
        var widths = new[] { 8, 30, 15, 40, 15, 14, 14 };

        var headerRow = sheet.CreateRow(0);
        for (int i = 0; i < headers.Length; i++)
        {
            var cell = headerRow.CreateCell(i);
            cell.SetCellValue(headers[i]);
            cell.CellStyle = headerStyle;
            sheet.SetColumnWidth(i, widths[i] * 256); // NPOI 列宽单位
        }

        // ====== 数据行 ======
        for (int i = 0; i < result.Items.Count; i++)
        {
            var item = result.Items[i];
            var row = sheet.CreateRow(i + 1);
            var isHighDensity = item.NearbyCount > 50;

            void SetCell(int col, object value)
            {
                var cell = row.CreateCell(col);
                if (value is string s) cell.SetCellValue(s);
                else if (value is int n) cell.SetCellValue(n);
                else if (value is double d) cell.SetCellValue(d);

                cell.CellStyle = isHighDensity ? highDensityStyle : dataStyle;
            }

            SetCell(0, i + 1);
            SetCell(1, item.Name);
            SetCell(2, item.Category);
            SetCell(3, item.Address);
            SetCell(4, item.NearbyCount);
            SetCell(5, item.Longitude);
            SetCell(6, item.Latitude);
        }

        // ====== 冻结首行 ======
        sheet.CreateFreezePane(0, 1);

        // ====== 自动筛选 ======
        sheet.SetAutoFilter(new CellRangeAddress(0, result.Items.Count, 0, headers.Length - 1));

        // ====== 保存文件 ======
        var outputDir = Path.Combine(AppContext.BaseDirectory, "exports");
        Directory.CreateDirectory(outputDir);
        var fileName = $"POI_{DateTime.Now:yyyyMMdd_HHmmss}.xlsx";
        var filePath = Path.Combine(outputDir, fileName);

        await using var fileStream = new FileStream(filePath, FileMode.Create, FileAccess.Write);
        workbook.Write(fileStream);

        return filePath;
    }
}

// PoiController.cs — API 控制器
// Furion 控制器的标准模式

using Furion.DynamicApiController;
using Microsoft.AspNetCore.Mvc;

namespace GisApi.Controllers;

[ApiController]
[Route("api/poi")]
public class PoiController : IDynamicApiController
{
    private readonly PoiService _poiService;
    private readonly PoiExportService _exportService;

    public PoiController(PoiService poiService, PoiExportService exportService)
    {
        _poiService = poiService;
        _exportService = exportService;
    }

    /// <summary>
    /// 分页查询 POI 列表
    /// </summary>
    [HttpGet("list")]
    public async Task<IActionResult> GetPagedList([FromQuery] PoiQueryInput input)
    {
        var result = await _poiService.QueryPagedAsync(input);
        return Ok(new { code = 200, data = result });
    }

    /// <summary>
    /// 按分类统计
    /// </summary>
    [HttpGet("stats")]
    public async Task<IActionResult> GetStats()
    {
        var stats = await _poiService.GetCategoryStatsAsync();
        return Ok(new { code = 200, data = stats });
    }

    /// <summary>
    /// 导出 Excel
    /// </summary>
    [HttpGet("export")]
    public async Task<IActionResult> Export([FromQuery] PoiQueryInput input)
    {
        var filePath = await _exportService.ExportToExcelAsync(input);
        var bytes = await System.IO.File.ReadAllBytesAsync(filePath);
        return File(bytes, "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
                    Path.GetFileName(filePath));
    }
}