// ==========================================================================
// GFast自动生成controller操作代码。
// 生成日期：2023-07-31 11:20:54
// 生成路径: internal/app/system/controller/qianqi_fangzhen.go
// 生成人：gfast
// desc:方阵
// company:云南奇讯科技有限公司
// ==========================================================================

package controller

import (
	"context"
	"encoding/json"
	"errors"
	"fmt"
	"github.com/gogf/gf/v2/crypto/gmd5"
	"github.com/gogf/gf/v2/database/gdb"
	"github.com/gogf/gf/v2/frame/g"
	"github.com/google/uuid"
	"github.com/jinzhu/copier"
	"github.com/tiger1103/gfast/v3/api/v1/common/shp"
	tool2 "github.com/tiger1103/gfast/v3/api/v1/common/tool"
	"github.com/tiger1103/gfast/v3/api/v1/system"
	"github.com/tiger1103/gfast/v3/internal/app/system/dao"
	ct "github.com/tiger1103/gfast/v3/internal/app/system/logic/context"
	"github.com/tiger1103/gfast/v3/internal/app/system/model"
	"github.com/tiger1103/gfast/v3/internal/app/system/model/do"
	"github.com/tiger1103/gfast/v3/internal/app/system/model/entity"
	"github.com/tiger1103/gfast/v3/internal/app/system/service"
	"github.com/tiger1103/gfast/v3/library/liberr"
	"github.com/tiger1103/gfast/v3/third/create"
	tool "github.com/tiger1103/gfast/v3/utility/coryUtils"
	"math/rand"
	"os"
	"os/exec"
	"strconv"
	"strings"
	"time"
)

type qianqiDxfController struct {
	BaseController
}

var QianqiDxf = new(qianqiDxfController)

func (c *qianqiDxfController) FzFunc(ctx context.Context, req *system.FzReq) (res *system.FzRes, err error) {
	err = g.DB().Transaction(ctx, func(ctx context.Context, tx gdb.TX) error {
		err = g.Try(ctx, func(ctx context.Context) {
			//1、获取数据
			point := req.Point
			plane := req.Plane
			//2、合并名称
			var listE []system.FacFeatureByPlane //面
			for _, data := range plane {
				adata := system.FacFeatureByPlane{}
				for _, bdata := range data.Features {
					copier.Copy(&adata, &bdata)
					listE = append(listE, adata)
				}

			}
			var listT []system.FacFeatureByPoint //点
			for _, data := range point {
				adata := system.FacFeatureByPoint{}
				for _, bdata := range data.Features {
					copier.Copy(&adata, &bdata)
					listT = append(listT, adata)
				}
			}
			var templateDataList []do.WorkStatus
			//3、循环判断坐标是否在点内
			for _, i := range listE {
				var minVal float64
				var fzName string
				for num, j := range listT {
					inPolygon := tool.FanWei(i.Geometry.Coordinates[0], j.Geometry.Coordinates)
					//如果为true，说明在多边形内
					if inPolygon {
						//直接确认数据
						fzName = j.Properties.Text //名字
					} else {
						distance := tool.PointToPolygonDistance(i.Geometry.Coordinates[0], j.Geometry.Coordinates)
						fmt.Printf("点到多边形的最短距离（单位米）：%.2f m\n", distance)
						if num == 0 {
							if len(listT) == 1 { //只有一个情况下直接赋值
								minVal = distance
								fzName = j.Properties.Text //名字
								break
							}
							minVal = distance
							fzName = j.Properties.Text //名字
						} else {
							if distance < minVal {
								minVal = distance
								fzName = j.Properties.Text //名字
							}
						}
					}
				}
				//得到详情数据（方阵）
				points := []shp.Point{}
				for _, jwd := range i.Geometry.Coordinates[0] {
					points = append(points, shp.Point{
						Lng: jwd[0],
						Lat: jwd[1],
					})
				}
				polygon := shp.Polygon{
					Positions: points,
				}
				marshal, err := json.Marshal(polygon)
				if err != nil {
					liberr.ErrIsNil(ctx, err, "详情获取失败")
				}
				//分割名称
				if fzName != "" {
					fzName = strings.Split(fzName, " ")[0]
				}
				// 将方阵的名称  作为方阵的id
				fangzhen, err := dao.QianqiFangzhen.Ctx(ctx).Insert(&do.QianqiFangzhen{
					ProjectId: req.SubProjectId,
					Name:      fzName,
					SourceId:  tool2.GetUuid(),
					CreateBy:  ct.New().GetLoginUser(ctx).Id,
					Detail:    string(marshal),
				})
				templateID, err := fangzhen.LastInsertId()
				if err != nil {
					continue
				}
				templateData, err := create.FetchTemplateData(ctx, templateID)
				if err != nil {
					continue
				}
				templateDataList = append(templateDataList, templateData...)
			}
			_, err = dao.WorkStatus.Ctx(ctx).Data(templateDataList).Batch(50).Insert()
		})
		return err
	})
	return
}

func (c *qianqiDxfController) XbFunc(ctx context.Context, req *system.XbReq) (res *system.XbRes, err error) {
	var xbList []shp.Polyline
	err = g.DB().Transaction(ctx, func(ctx context.Context, tx gdb.TX) error {
		err = g.Try(ctx, func(ctx context.Context) {
			/**
			一、箱变的录入
			*/
			var listE []system.FacFeatureByPoint //面
			for _, data := range req.Plane {
				adata := system.FacFeatureByPoint{}
				for _, bdata := range data.Features {
					copier.Copy(&adata, &bdata)
					listE = append(listE, adata)
				}
			}
			var listT []system.FacFeatureByPoint //点
			for _, data := range req.Point {
				adata := system.FacFeatureByPoint{}
				for _, bdata := range data.Features {
					copier.Copy(&adata, &bdata)
					listT = append(listT, adata)
				}
			}
			var xiangbianArray []do.QianqiXiangbian
			//3、循环判断坐标是否在点内
			for _, i := range listE {
				var minVal float64
				var fzName string
				for num, j := range listT {
					distance := tool.PointToPointDistance(i.Geometry.Coordinates, j.Geometry.Coordinates)
					if num == 0 {
						if len(listT) == 1 { //只有一个情况下直接赋值
							minVal = distance
							fzName = j.Properties.Text //名字
							break
						}
						minVal = distance
						fzName = j.Properties.Text //名字
					} else {
						if distance < minVal {
							minVal = distance
							fzName = j.Properties.Text //名字
						}
					}
				}
				if fzName != "" {
					fzName = strings.Split(fzName, " ")[0]
				}
				//得到详情数据（箱变）
				points := []shp.Point{
					{
						Lng: i.Geometry.Coordinates[0],
						Lat: i.Geometry.Coordinates[1],
						Property: shp.Property{
							Name: fzName,
						},
					},
				}
				polylines := shp.Polyline{
					Positions: points,
					Property: shp.Property{
						Name: fzName,
					},
				}
				xbList = append(xbList, polylines)
				marshal, err := json.Marshal(polylines)
				if err != nil {
					liberr.ErrIsNil(ctx, err, "详情获取失败")
				}
				xb := do.QianqiXiangbian{
					ProjectId: req.SubProjectId,
					SourceId:  gmd5.MustEncryptString(req.ProjectId + fzName),
					Name:      fzName,
					ModelId:   "518bb3c165e22097ebbf2c2c42c8e308",
					CreateBy:  ct.New().GetLoginUser(ctx).Id,
					Detail:    string(marshal),
				}
				// 判断是否已经存在了该方阵，存在了就不再添加
				count, _ := dao.QianqiXiangbian.Ctx(ctx).Where(dao.QianqiXiangbian.Columns().SourceId, xb.SourceId).Count()
				if count == 0 {
					xiangbianArray = append(xiangbianArray, xb)
				}
			}
			if len(xiangbianArray) > 0 {
				_, err = dao.QianqiXiangbian.Ctx(ctx).Insert(&xiangbianArray)
				liberr.ErrIsNil(ctx, err, "添加失败")
			}
			/**
			二、需要操作pvmodel
			*/
			if err == nil {
				//1、获取当前项目的所有方阵，然后判断箱变是否在方阵内（或最近），然后记录方阵id
				var fzres []*model.QianqiFangzhenInfoRes
				dao.QianqiFangzhen.Ctx(ctx).Where(dao.QianqiFangzhen.Columns().ProjectId, req.SubProjectId).Scan(&fzres)
				for _, fz := range fzres {
					var minVal float64
					var fzId int
					var data *shp.Polyline
					// 解析JSON数据
					var polygon shp.Polygon
					err = json.Unmarshal([]byte(fz.Detail), &polygon)
					array := tool.ConvertPolygonToFloatArray(polygon)
					for num, xb := range xbList {
						numbers := []float64{xb.Positions[0].Lng, xb.Positions[0].Lat}
						wei := tool.FanWei(array, numbers)
						//如果为true，说明在多边形内
						if wei {
							fzId = fz.Id
							data = &xb
						} else {
							distance := tool.PointToPolygonDistance(array, numbers)
							if num == 0 {
								if len(xbList) == 1 { //只有一个情况下直接赋值
									minVal = distance
									fzId = fz.Id
									data = &xb
									break
								}
								minVal = distance
								fzId = fz.Id
								data = &xb
							} else {
								if distance < minVal {
									minVal = distance
									fzId = fz.Id
									data = &xb
								}
							}
						}
					}
					if data != nil {
						err := service.PvModule().ImportCory(ctx, &system.PvModuleImportCory{
							FangZhenID:   strconv.Itoa(fzId),
							ProjectID:    req.ProjectId,
							SubProjectID: req.SubProjectId,
							Shapes: &shp.ShpObj{
								Polylines: []shp.Polyline{
									*data,
								},
							},
						})
						liberr.ErrIsNil(ctx, err, "pvmodel箱变录入失败")
					}
				}
			}
		})
		return err
	})
	return
}

func (c *qianqiDxfController) NbqFunc(ctx context.Context, req *system.NbqReq) (res *system.NbqRes, err error) {
	var nbqList []shp.Polyline
	err = g.DB().Transaction(ctx, func(ctx context.Context, tx gdb.TX) error {
		err = g.Try(ctx, func(ctx context.Context) {
			/**
			一、处理逆变器数据
			*/
			//1、获取数据
			point := req.Point
			plane := req.Plane
			//2、合并名称
			var listE []system.FacFeatureByPoint //面
			for _, data := range plane {
				adata := system.FacFeatureByPoint{}
				for _, bdata := range data.Features {
					copier.Copy(&adata, &bdata)
					listE = append(listE, adata)
				}
			}
			var listT []system.FacFeatureByPoint //点
			for _, data := range point {
				adata := system.FacFeatureByPoint{}
				for _, bdata := range data.Features {
					copier.Copy(&adata, &bdata)
					listT = append(listT, adata)
				}
			}
			var arr []do.QianqiNibianqi
			//3、循环判断坐标是否在点内
			for _, i := range listE {
				var minVal float64
				var fzName string
				for num, j := range listT {
					distance := tool.PointToPointDistance(i.Geometry.Coordinates, j.Geometry.Coordinates)
					if num == 0 {
						if len(listT) == 1 { //只有一个情况下直接赋值
							minVal = distance
							fzName = j.Properties.Text //名字
							break
						}
						minVal = distance
						fzName = j.Properties.Text //名字
					} else {
						if distance < minVal {
							minVal = distance
							fzName = j.Properties.Text //名字
						}
					}
					//}
				}
				if fzName != "" {
					fzName = strings.Split(fzName, " ")[0]
				}
				//得到详情数据（方阵）
				points := []shp.Point{
					{
						Lng: i.Geometry.Coordinates[0],
						Lat: i.Geometry.Coordinates[1],
						Property: shp.Property{
							Name: fzName,
						},
					},
				}
				polylines := shp.Polyline{
					Positions: points,
					Property: shp.Property{
						Name: fzName,
					},
				}
				nbqList = append(nbqList, polylines)
				marshal, err := json.Marshal(polylines)
				if err != nil {
					liberr.ErrIsNil(ctx, err, "详情获取失败")
				}
				nibianqi := do.QianqiNibianqi{}
				nibianqi.ProjectId = req.SubProjectId
				nibianqi.SourceId = gmd5.MustEncryptString(req.ProjectId + fzName)
				nibianqi.Name = fzName
				nibianqi.ModelId = "41b366a9bae250098716da675d3ae26d"
				nibianqi.CreateBy = ct.New().GetLoginUser(ctx).Id
				nibianqi.Detail = string(marshal)
				// 判断是否已经存在了该方阵，存在了就不再添加
				count, _ := dao.QianqiNibianqi.Ctx(ctx).Where(dao.QianqiNibianqi.Columns().SourceId, nibianqi.SourceId).Count()
				if count == 0 {
					arr = append(arr, nibianqi)
				}
			}
			if len(arr) > 0 {
				_, err = dao.QianqiNibianqi.Ctx(ctx).Insert(&arr)
				liberr.ErrIsNil(ctx, err, "添加失败")
			}
			/**
			二、进行pvmodel数据处理
			*/
			if err == nil {
				//1、获取当前项目的所有方阵，然后判断箱变是否在方阵内（或最近），然后记录方阵id
				var fzres []*model.QianqiFangzhenInfoRes
				dao.QianqiFangzhen.Ctx(ctx).Where(dao.QianqiFangzhen.Columns().ProjectId, req.SubProjectId).Scan(&fzres)
				for _, fz := range fzres {
					var minVal float64
					var fzId int
					var data *shp.Polyline
					// 解析JSON数据
					var polygon shp.Polygon
					err = json.Unmarshal([]byte(fz.Detail), &polygon)
					array := tool.ConvertPolygonToFloatArray(polygon)
					for num, xb := range nbqList {
						numbers := []float64{xb.Positions[0].Lng, xb.Positions[0].Lat}
						wei := tool.FanWei(array, numbers)
						//如果为true，说明在多边形内
						if wei {
							fzId = fz.Id
						} else {
							distance := tool.PointToPolygonDistance(array, numbers)
							if num == 0 {
								if len(nbqList) == 1 { //只有一个情况下直接赋值
									minVal = distance
									fzId = fz.Id
									data = &xb
									break
								}
								minVal = distance
								fzId = fz.Id
								data = &xb
							} else {
								if distance < minVal {
									minVal = distance
									fzId = fz.Id
									data = &xb
								}
							}
						}
					}
					if data != nil {
						err := service.PvModule().ImportInverterCory(ctx, &system.ImportInverterCory{
							FangZhenID:   strconv.Itoa(fzId),
							ProjectID:    req.ProjectId,
							SubProjectID: req.SubProjectId,
							Shapes: &shp.ShpObj{
								Polylines: []shp.Polyline{
									*data,
								},
							},
						})
						liberr.ErrIsNil(ctx, err, "pvmodel逆变器录入失败")
					}
				}
			}
		})
		return err
	})
	return
}

func (c *qianqiDxfController) GfbFunc(ctx context.Context, req *system.GfbReq) (res *system.GfbRes, err error) {
	err = g.DB().Transaction(ctx, func(ctx context.Context, tx gdb.TX) error {
		err = g.Try(ctx, func(ctx context.Context) {
			var gfbList []shp.Polyline
			var eles []do.QianqiGuangfubanIds
			/**
			一、处理光伏板数据
			*/
			//1、获取数据
			point := req.Point
			plane := req.Plane
			//2、合并名称
			var listE []system.FacFeatureByPlane //面
			for _, data := range plane {
				adata := system.FacFeatureByPlane{}
				for _, bdata := range data.Features {
					copier.Copy(&adata, &bdata)
					listE = append(listE, adata)
				}
			}
			var listT []system.FacFeatureByPoint //点
			for _, data := range point {
				adata := system.FacFeatureByPoint{}
				for _, bdata := range data.Features {
					copier.Copy(&adata, &bdata)
					listT = append(listT, adata)
				}
			}
			//3、循环判断坐标是否在点内
			for _, i := range listE {
				var minVal float64
				var fzName string
				for num, j := range listT {
					inPolygon := tool.FanWei(i.Geometry.Coordinates[0], j.Geometry.Coordinates)
					//如果为true，说明在多边形内
					if inPolygon {
						//直接确认数据
						fzName = j.Properties.Text //名字
						break
					} else {
						distance := tool.PointToPolygonDistance(i.Geometry.Coordinates[0], j.Geometry.Coordinates)
						if num == 0 {
							if len(listT) == 1 { //只有一个情况下直接赋值
								minVal = distance
								fzName = j.Properties.Text //名字
								break
							}
							minVal = distance
							fzName = j.Properties.Text //名字
						} else {
							if distance < minVal {
								minVal = distance
								fzName = j.Properties.Text //名字
							}
						}
					}
				}
				if fzName != "" {
					fzName = strings.Split(fzName, " ")[0]
				}
				//得到详情数据（方阵）
				points := []shp.Point{}
				for _, jwd := range i.Geometry.Coordinates[0] {
					points = append(points, shp.Point{
						Lng: jwd[0],
						Lat: jwd[1],
						Property: shp.Property{
							Name: fzName,
						},
					})
				}
				polylines := shp.Polyline{
					Positions: points,
					Property: shp.Property{
						Name: fzName,
					},
				}
				gfbList = append(gfbList, polylines)
				marshal, err := json.Marshal(polylines)
				if err != nil {
					liberr.ErrIsNil(ctx, err, "详情获取失败")
				}
				//===================
				if !strings.HasPrefix(fzName, "G") {
					continue
				}
				// 设置随机数种子
				rand.Seed(time.Now().UnixNano())
				randomNum := rand.Intn(6) + 1
				randomStr1 := strconv.Itoa(randomNum)
				ele := do.QianqiGuangfubanIds{
					Name:       fzName,
					DevType:    "1",
					CreateBy:   ct.New().GetLoginUser(ctx).Id,
					SourceType: "guangfuban",
					SourceId:   tool2.GetUuid() + randomStr1,
					ProjectId:  req.SubProjectId,
					Range:      string(marshal),
				}
				eles = append(eles, ele)
				if len(eles) > 500 {
					dao.QianqiGuangfubanIds.Ctx(ctx).Insert(eles)
					eles = []do.QianqiGuangfubanIds{}
				}
			}

			/**
			二、进行pvmodel数据处理
			*/
			if err == nil {
				//1、获取当前项目的所有方阵，然后判断箱变是否在方阵内（或最近），然后记录方阵id
				fzres := []entity.QianqiFangzhen{}
				queryErr := dao.QianqiFangzhen.Ctx(ctx).
					Where(dao.QianqiFangzhen.Columns().ProjectId, req.SubProjectId).
					Scan(&fzres)
				if queryErr != nil {
					liberr.ErrIsNil(ctx, queryErr, "方阵获取失败")
					return
				}
				for _, fz := range fzres {
					var data []shp.Polyline
					// 解析JSON数据
					var polygon shp.Polygon
					err = json.Unmarshal([]byte(fz.Detail), &polygon)
					array := tool.ConvertPolygonToFloatArray(polygon)
					for _, xb := range gfbList {
						numbers := []float64{xb.Positions[0].Lng, xb.Positions[0].Lat}
						wei := tool.FanWei(array, numbers)
						//如果为true，说明在多边形内
						if wei {
							polyline := shp.Polyline{}
							polyline = xb
							data = append(data, polyline)
						}
					}
					if data != nil {
						err := service.PvModule().ImportPvBoardCory(ctx, &system.ImportPvBoardCory{
							FangZhenID:   strconv.Itoa(fz.Id),
							ProjectID:    req.ProjectId,
							SubProjectID: req.SubProjectId,
							Shapes: &shp.ShpObj{
								Polylines: data,
							},
							Fangzhens: fzres,
						})
						liberr.ErrIsNil(ctx, err, "pvmodel光伏板录入失败")
					}
				}
			}

		})
		return err
	})
	return
}

// 传入 point 构建出 detail 和 SourceID
func buildDetailAndSourceID(point shp.Point, name string) (string, string) {
	// 生成 SourceID
	sourceID := fmt.Sprintf("%s.%s", point.Name, strings.ReplaceAll(uuid.New().String(), "-", ""))

	detail := Zhuangdian{
		Position: point,
	}
	detail.Position.SourceId = sourceID

	// 序列化后传回
	data, err := json.Marshal(detail)
	if err != nil {
		return "", ""
	}
	return string(data), sourceID
}

func (c *qianqiDxfController) ZhuangDianFunc(ctx context.Context, req *system.ZdReq) (res *system.ZdRes, err error) {
	//1、获取数据
	plane := req.Plane
	//2、合并名称
	var listE []system.FacFeatureByPoint //面
	for _, data := range plane {
		adata := system.FacFeatureByPoint{}
		for _, bdata := range data.Features {
			copier.Copy(&adata, &bdata)
			listE = append(listE, adata)
		}
	}
	//3-1、获取到所有的方阵、光伏板,获取到方阵id根布版图绑定
	fzres := []entity.QianqiFangzhen{}
	queryErr := dao.QianqiFangzhen.Ctx(ctx).
		Where(dao.QianqiFangzhen.Columns().ProjectId, req.SubProjectid).
		Scan(&fzres)
	if queryErr != nil {
		liberr.ErrIsNil(ctx, queryErr, "方阵获取失败")
		return
	}
	columns := dao.QianqiGuangfubanIds.Columns()
	var resData []*model.QianqiGuangfubanIdsInfoRes
	dao.QianqiGuangfubanIds.Ctx(ctx).Where(columns.ProjectId, req.SubProjectid).Scan(&resData)
	if resData == nil && len(resData) == 0 {
		liberr.ErrIsNil(ctx, errors.New("光伏板获取失败"))
		return
	}
	for i, datum := range resData {
		//布版图
		var polygon1 shp.Polygon
		err = json.Unmarshal([]byte(datum.Range), &polygon1)
		if err != nil {
			liberr.ErrIsNil(ctx, err, "详情获取失败")
			return
		}
		f64 := []float64{polygon1.Positions[0].Lng, polygon1.Positions[0].Lat}
		for _, fzre := range fzres { //方阵
			//解析JSON数据
			var polygon shp.Polygon
			err = json.Unmarshal([]byte(fzre.Detail), &polygon)
			if err != nil {
				liberr.ErrIsNil(ctx, err, "详情获取失败")
				return
			}
			array2 := tool.ConvertPolygonToFloatArray(polygon)
			if tool.FanWei(array2, f64) {
				resData[i].FzId = fzre.Id
			}
		}
	}
	//3-2、获取布版图
	if resData != nil && len(resData) > 0 {
		insertList := []do.QianqiGuangfubanIdsZhuangdian{}
		for _, i := range resData { //面
			num := 0
			r := i.Range
			// 解析JSON数据
			var polygon shp.Polygon
			err = json.Unmarshal([]byte(r), &polygon)
			if err != nil {
				return nil, err
			}
			//判断点是否在多边形内
			array := tool.ConvertPolygonToFloatArray(polygon)
			for _, j := range listE { //坐标点（）
				inPolygon := tool.FanWei(array, j.Geometry.Coordinates)
				if inPolygon {
					num = num + 1
					// 调用 buildDetailAndSourceID 生成 detail 和 SourceID
					pointcory := shp.Point{
						Lng: j.Geometry.Coordinates[0],
						Lat: j.Geometry.Coordinates[1],
						Property: shp.Property{
							Name: j.Geometry.Type,
						},
					}
					_, sourceID := buildDetailAndSourceID(pointcory, j.Geometry.Type)
					points := []shp.Point{pointcory}
					polylines := shp.Polyline{Positions: points}
					marshal, err := json.Marshal(polylines)
					if err != nil {
						liberr.ErrIsNil(ctx, err, "详情获取失败")
					}
					zhuangdian := do.QianqiGuangfubanIdsZhuangdian{
						Name:         i.Name + "." + strconv.Itoa(num),
						SourceId:     sourceID,
						ProjectId:    req.ProjectId,
						Status:       "0",
						Detail:       marshal,
						SubProjectid: req.SubProjectid,
						FangzhenId:   i.FzId,
					}
					insertList = append(insertList, zhuangdian)
				}

			}
		}
		if len(insertList) > 0 {
			batchNumber := 700
			_, err = dao.QianqiGuangfubanIdsZhuangdian.Ctx(ctx).Batch(batchNumber).Insert(&insertList)
			liberr.ErrIsNil(ctx, err, "光伏板插入失败")
			_, err = dao.QianqiGuangfubanIdsLizhu.Ctx(ctx).Batch(batchNumber).Insert(&insertList)
			liberr.ErrIsNil(ctx, err, "立柱插入失败")
			_, err = dao.QianqiGuangfubanIdsZhijia.Ctx(ctx).Batch(batchNumber).Insert(&insertList)
			liberr.ErrIsNil(ctx, err, "支架失败")
		}
	}
	return
}

func (c *qianqiDxfController) DxfGet(ctx context.Context, req *system.DxfGetReq) (res *system.DxfGetRes, err error) {
	// 定义 exe <DXF文件的绝对路径><结果 JS0N 文件的绝对路径><源 EPSG 代码><目标 EPSG 代码>
	cmd := exec.Command("E:\\cory\\project\\go\\zmkgC\\resource\\public\\zmFiles\\pythonDxf.exe",
		"E:\\cory\\project\\go\\zmkgC\\resource\\public\\zmFiles\\b93ba1d7008247a79503e8a80fe1de62.dxf",
		"E:\\cory\\project\\go\\zmkgC\\resource\\public\\zmFiles\\nr.json",
		"4524",
		"4326",
	)
	// 执行并获取输出
	output, err := cmd.CombinedOutput()
	if err != nil {
		fmt.Println("执行出错:", err)
	}
	fmt.Println("输出内容:", string(output))
	return
}

func (c *qianqiDxfController) DxfData(ctx context.Context, req *system.DxfDataReq) (res *system.DxfDataRes, err error) {
	res = &system.DxfDataRes{}

	err = g.Try(ctx, func(ctx context.Context) {
		// 指定要读取的JSON文件路径
		filePath := "E:\\cory\\project\\go\\zmkgC\\resource\\public\\zmFiles\\nr.json"
		// 读取文件内容
		data, err := os.ReadFile(filePath)
		if err != nil {
			liberr.ErrIsNil(ctx, err, "读取失败")
		}

		// 用于存储解析后的JSON数据
		var result map[string]interface{}

		// 解析JSON数据
		if err := json.Unmarshal(data, &result); err != nil {
			liberr.ErrIsNil(ctx, err, "解析JSON失败")
		}
		res.Map = result
	})
	return
}

//
//func FanWei(mian [][]float64, dian [][]float64) bool {
//
//	// 定义多边形范围 (经纬度点的顺序很重要，需要闭合：首尾点相同)
//	polygon := orb.Polygon{
//		{
//			{106.518314, 29.627223}, // 起始位置
//			{106.519419, 29.627223},
//			{106.518238, 29.626399},
//			{106.519491, 29.626435},
//			{106.518314, 29.627223}, // 回到起始
//		},
//	}
//	// 目标点
//	point := orb.Point{106.518907, 29.626458} // 假设是一个经纬度点
//
//	// 判断点是否在多边形内
//	if planar.PolygonContains(polygon, point) {
//		fmt.Println("点在多边形范围内")
//		return true
//	} else {
//		fmt.Println("点不在多边形范围内")
//		return false
//	}
//}