using System;
using System.Drawing;
using System.IO;
using System.Windows.Forms;
using GeoScene.Data;
using GeoScene.Engine;
using GeoScene.Globe;

namespace Cyberpipe
{
    public class PointBuilder:ModelBuilder
    {
        static string filedPathF = Application.StartupPath + "\\雨篦工井模型\\";
        static string filedPathG = Application.StartupPath + "\\管道配件gcm\\";

        public PointBuilder(GSODataSource ds)
            : base(ds)
        { 
        
        }

        public override bool validate(GSOLayer layer) {
            return true;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="updateMode">追加或修改</param>
        /// <param name="buildMode">高程入库或埋深入库</param>
        /// <param name="param"></param>
        public override bool doBuild(EnumUpdateMode updateMode,
                                     EnumBuildMode buildMode,
                                     BaseParam param)
        {
            PointParam pointParam = param as PointParam;
            GSOFeatureDataset newFeatureSet = ds.GetDatasetByName(pointParam.layerName) as GSOFeatureDataset;
            if (newFeatureSet == null)
            {
                newFeatureSet = CreateDBFeatureDataset(layer, pointParam.layerName);
            }
            newFeatureSet.Open();
            GSOFeatures features = layer.GetAllFeatures(true);
            for (int i = 0; i < features.Length; i++)
            {
                GSOFeature f = features[i];
                GSOGeoPoint3D shapePoint = f.Geometry as GSOGeoPoint3D;

                GSOFeature newFeature = newFeatureSet.CreateFeature();

                newFeature.Name = f.GetValue(pointParam.uniqueIdFieldName).ToString();
                newFeature.Geometry = createModel(f, pointParam, buildMode);
                setFeatureValueByShapeFeature(f, newFeature);

                if (newFeatureSet.GetFeatureByName(newFeature.Name, true).Length > 0)
                { //存在
                    if (updateMode.Equals(EnumUpdateMode.Append))
                    {
                        continue;
                    }
                    GSOFeature delFeature = newFeatureSet.GetFeatureByName(newFeature.Name, true)[0];
                    delFeature.Delete();
                }
                newFeatureSet.AddFeature(newFeature);
            }
            newFeatureSet.Save();
            newFeatureSet.Close();
            return true;
        }

        private GSOGeoModel createModel(GSOFeature f,
            PointParam pointParam, EnumBuildMode buildMode)
        {
            GSOGeoPoint3D shapePoint = f.Geometry as GSOGeoPoint3D;
            GSOGeoModel model = new GSOGeoModel();
            GSOPoint3d pt = new GSOPoint3d();
            pt.X = shapePoint.X;
            pt.Y = shapePoint.Y;

            if (ExitFiled(f, "管点编码")) //特征管点
            {
                pt.Z = (buildMode.Equals(EnumBuildMode.Alititude)) ? Convert.ToDouble(f.GetValue(pointParam.z))
                    : Convert.ToDouble(f.GetValue(pointParam.altitudeFieldName)) - Convert.ToDouble(f.GetValue(pointParam.z));
            }
            else if (ExitFiled(f, "附属物编码")) //附属物
            {
                pt.Z = (buildMode.Equals(EnumBuildMode.Alititude)) ? Convert.ToDouble(f.GetValue(pointParam.altitudeFieldName).ToString())
               + pointParam.upGround : pointParam.upGround;
            }
            else
            {
                pt.Z = (buildMode.Equals(EnumBuildMode.Alititude)) ? Convert.ToDouble(f.GetValue(pointParam.altitudeFieldName))
               - Convert.ToDouble(f.GetValue(pointParam.wellDepthFiledName)) : Convert.ToDouble(f.GetValue(pointParam.wellDepthFiledName));
            }

            model.Position = pt;
            model.Align = EnumEntityAlign.TopCenter;//
            model.AltitudeMode = (buildMode.Equals(EnumBuildMode.Alititude)) ? EnumAltitudeMode.RelativeToGround : EnumAltitudeMode.Absolute;
            //model.RotateZ = (pointParam.symbolFiledName == "")?0:0 - (double)f.GetValue(pointParam.symbolFiledName) * 180 / Math.PI + 90;

            model.FilePath = getModelPath(f, pointParam);
            model.Name = f.GetValue(pointParam.uniqueIdFieldName).ToString();
            return model;
        }

        private String getModelPath(GSOFeature f, PointParam pointParam)
        {
            string feName = f.GetFieldAsString(pointParam.attachNameFieldName);
            string handle = f.GetFieldAsString(pointParam.pointEncodingFieldName);
            double deep = f.GetFieldAsDouble(pointParam.wellDepthFiledName);
            //TODO LIST:获取模型路径

            if(ExitFiled(f, "管点编码")) //特征管点
            {
                return filedPathG + feName + "\\" + feName + ".gcm";
            }
            if (ExitFiled(f, "附属物编码")) //附属物
            {
                deep = Math.Round(deep, 0);

                for (int i = 0; i < 10; i++)
                {
                    string strDeep = (deep + i).ToString("0.00");
                    if (File.Exists(filedPathF + handle + "-" + strDeep + ".gcm"))
                        return filedPathF + handle + "-" + strDeep + ".gcm";
                }
                return "";
            }
            return filedPathF + handle + ".gcm";
        }

        private bool ExitFiled(GSOFeature feature, string filedName)
        {
            GSOFeatureDataset featDataSet = feature.Dataset as GSOFeatureDataset;
            for (int i = 0; i < featDataSet.FieldCount; i++)
            {
                if (featDataSet.GetField(i).Name == filedName)
                    return true;
            }
            return false;
        }

        private double getRadius(LineParam lineParam, GSOFeature f) {
            double radius = 0;
            GSOFieldDefn field = f.GetFieldDefn(lineParam.diameterFieldName);
            if (field.Type == EnumFieldType.Text)
            {
                string temp = f.GetFieldAsString(lineParam.diameterFieldName);
                double outNum = 0;
                bool num = double.TryParse(temp, out outNum);
                if (num)
                    radius = outNum / 2000;
            }
            else if (field.Type == EnumFieldType.Double || field.Type == EnumFieldType.INT32)
                radius = f.GetFieldAsDouble(lineParam.diameterFieldName) / 2000;  // 探测数据的单位一般是毫米，需换算为米； 管径一般是 直径， 这个需要半径， 所有除以2000 
            return radius;
        }

        /**
         * 获取管线style
         **/
        private GSOPipeLineStyle3D getPipeLineStyle(LineParam lineParam,GSOFeature f,double radius) {

            GSOPipeLineStyle3D style = new GSOPipeLineStyle3D();
            style.LineColor = Color.FromArgb(lineParam.transparency, lineParam.lineColor);
            style.Slice = lineParam.sliceNum;
            style.CornerSliceAngle = lineParam.cornerSliceAngle;
            style.Radius = radius;

            return style;
        }
       
        private GSOGeometry updateGemotry(GSOFeature f,LineParam lineParam,double radius, EnumBuildMode buildMode){

            f.Geometry.AltitudeMode = (buildMode.Equals(EnumBuildMode.Alititude)) ? EnumAltitudeMode.RelativeToGround : EnumAltitudeMode.Absolute;

            GSOGeoPolyline3D line = f.Geometry as GSOGeoPolyline3D;
            if (line == null) {
                return null; //log4net 记录错误处理
            }

            double deep1 = f.GetFieldAsDouble(lineParam.startDepthFieldName);
            double deep2 = f.GetFieldAsDouble(lineParam.endDepthFieldName);
            deep1 = lineParam.isRevert ? -deep1 : deep1;
            deep2 = lineParam.isRevert ? -deep2 : deep2;
            
            //根据相对模式进行深度修改
            deep1 = lineParam.relativeMode==1?deep1+radius*2:deep1-radius*2;
            deep2 = lineParam.relativeMode==1?deep2+radius*2:deep2-radius*2;

            GSOPoint3ds pt3ds = new GSOPoint3ds();
            for (int n = 0; n < line[0].Count; n++)
            {
                GSOPoint3d pt3d = line[0][n];
                int pointcount = line[0].Count;
                //TODO LIST:BUG 
                double totalLength = Math.Sqrt(Math.Pow(line[0][pointcount - 1].Y - line[0][0].Y, 2) + Math.Pow(line[0][pointcount - 1].X - line[0][0].X, 2));
                if (totalLength == 0)
                {
                    //TODOLIST:ERROR log4net
                    pt3d.Z = deep1;
                }
                else
                {
                    double radio = Math.Sqrt(Math.Pow(pt3d.Y - line[0][0].Y, 2) + Math.Pow(pt3d.X - line[0][0].X, 2)) / totalLength;
                    pt3d.Z = deep1 + (deep2 - deep1) * radio;
                }

                if (double.IsInfinity(pt3d.Z))
                {
                    //TODOLIST:ERROR log4net
                    pt3d.Z = deep2;
                    //MessageBox.Show("无穷！");
                }
                pt3ds.Add(pt3d);
            }
            line[0] = pt3ds;

            return line;
        }

        private void setFeatureValueByShapeFeature(GSOFeature src,GSOFeature dst) {

            for (int j = 0; j < dst.GetFieldCount(); j++)
            {
                if (src.GetFieldCount() > j)
                {
                    GSOFieldDefn fielddef = src.GetFieldDefn(j);

                    object fieldvalue = src.GetValue(fielddef.Name);// convertFieldValue(fielddef.Name, f.GetValue(fielddef.Name));
                    dst.SetValue(fielddef.Name, fieldvalue);
                    /*
                    if (fieldvalue == null)
                        continue;
                    string fieldName = en_cns.ContainsKey(fielddef.Name) == true ? en_cns[fielddef.Name].ToString() : fielddef.Name;
                    dst.SetValue(fieldName, fieldvalue);
                     * */

                }
            }

        }
    }
}