using Autodesk.Revit.Attributes;
using Autodesk.Revit.DB;
using Autodesk.Revit.UI;

using Microsoft.Win32;

using Newtonsoft.Json;

using Nice3point.Revit.Toolkit.External;

using System;

using System.Data;

using System.Linq;

using System.Windows;

using Szmedi.RvKits.ExportFamilyInfo;

namespace Szmedi.RvKits.FamilyTools
{
    [Transaction(TransactionMode.Manual)]

    public class ComponentInfoCmd : ExternalCommand
    {
        public override void Execute()
        {
            //AssemblyLoaderHelpers loader = new(GlobalVariables.DirAssembly);
            ExportSettingsWin settings = null;
            settings = new ExportSettingsWin();
            settings.ShowDialog();
            //loader.HookAssemblyResolve();
            //try
            //{

            //}
            //catch (Exception ex)
            //{
            //    LogAssists.WriteLog(ex.Message);
            //    Result = Result.Failed;
            //}
            //finally
            //{
            //    loader.UnhookAssemblyResolve();
            //}

            if (settings.DialogResult != true)
            {
                Result = Result.Cancelled;
                return;
            }
            OpenFileDialog openFileDialog = new()
            {
                Filter = "���ļ�(*.rfa)|*.rfa",
                Multiselect = true
            };
            var savepath = Properties.Settings.Default.SavePath;

            //Autodesk.Revit.UI.FileOpenDialog fileOpenDialog = new FileOpenDialog("���ļ�(*.rfa)|*.rfa");
            //fileOpenDialog.Show();
            //fileOpenDialog.GetSelectedModelPath();
            if (openFileDialog.ShowDialog() == true)
            {
                foreach (var filename in openFileDialog.FileNames)
                {
                    var famdoc = Application.OpenDocumentFile(filename);
                    var dictJson = DictParas(famdoc);
                    try
                    {
                        DictionaryToJson(filename, dictJson, savepath);
                    }
                    catch (Exception ex)
                    {
                        LogAssists.WriteLog(ex.Message);
                    }

                    ExportThumbnail(savepath, filename, famdoc);
                    famdoc.Close(false);
                    var famFullPath = Path.Combine(savepath, Path.GetFileNameWithoutExtension(filename), Path.GetFileName(filename));
                    //DirectoryInfo FamDir = new DirectoryInfo(FamPath);
                    //if (!FamDir.Exists)
                    //{
                    //    FamDir.Create();
                    //}
                    //File.Move(fullPath, FamFullPath);
                    FileInfo file = new(famFullPath);
                    if (file.Exists)
                    {
                        file.Delete();
                    }

                    File.Copy(filename, famFullPath);
                }
            }
        }

        private DataTable DtParasToExcel(Document doc, FamilyManager fm) //��ȡ���ļ�����
        {
            //StringBuilder sb = new StringBuilder();//�õ����е�ö������
            //sb.Append(famdoc.Title + "\r\n");
            var ft = fm.CurrentType; //��ȡ��ǰ����
            DataTable dt = new();
            //dt.Columns.Add("������", typeof(string));
            dt.Columns.Add("����", typeof(string));
            dt.Columns.Add("����ֵ", typeof(string));
            dt.Columns.Add("��ʽ", typeof(string));
            if (ft == null)
            {
                //IList<FamilyParameter> faparas = fm.GetParameters();
                //foreach (var para in faparas)
                //{
                //    sb.Append(para.Definition.Name);
                //}
                using Transaction trans = new(doc);
                trans.Start("�½�������");
                var NT = "NewType";
                ft = fm.NewType(NT);
                trans.Commit();
            }

            List<BuiltInParameterGroup> pgs = [];
            foreach (FamilyParameter para in fm.Parameters)
            {
                if (!pgs.Contains(para.Definition.ParameterGroup))
                {
                    pgs.Add(para.Definition.ParameterGroup);
                }
            }

            foreach (var pg in pgs)
            {
                var drpg = dt.NewRow();
                drpg[0] = null;
                drpg[1] = LabelUtils.GetLabelFor(pg);
                drpg[2] = null;
                dt.Rows.Add(drpg);
                foreach (FamilyParameter para in fm.Parameters)
                {
                    if (para.Definition.ParameterGroup == pg)
                    {
                        var drpara = dt.NewRow();
                        drpara[0] = para.Definition.Name;
                        drpara[1] = ft.AsValueString(para);
                        drpara[2] = para.Formula;
                        dt.Rows.Add(drpara);
                    }
                }
            }

            return dt;

            //foreach (FamilyParameter para in fm.Parameters)
            //{
            //    DataRow dr = dt.NewRow();
            //    dr[0] = LabelUtils.GetLabelFor(para.Definition.ParameterGroup);
            //    dr[1] = para.Definition.Name;
            //    dr[2] = ft.AsValueString(para);
            //    dt.Rows.Add(dr);

            //    //sb.Append(para.Definition.ParameterGroup + ":" + para.Definition.Name + ":" + ft.AsValueString(para) + "\r\n");
            //    //switch (para.StorageType)
            //    //{
            //    //    case StorageType.Double:
            //    //        sb.Append(para.Definition.Name + ":" + ft.AsDouble(para) * 304.8 + "\r\n");
            //    //        break;
            //    //    case StorageType.Integer:
            //    //        sb.Append(para.Definition.Name + ":" + ft.AsInteger(para) * 304.8 + "\r\n");
            //    //        break;
            //    //    case StorageType.ElementId:
            //    //        sb.Append(para.Definition.Name + ":" + ft.AsElementId(para) + "\r\n");
            //    //        break;
            //    //    case StorageType.String:
            //    //        sb.Append(para.Definition.Name + ":" + ft.AsString(para) + "\r\n");
            //    //        break;
            //    //    case StorageType.None:
            //    //        break;
            //    //}
            //}
            //TaskDialog.Show(header, sb.ToString());
        }

        private DataTable DtParasToJson(Document doc) //��ȡ���ļ�����
        {
            //StringBuilder sb = new StringBuilder();//�õ����е�ö������
            //sb.Append(famdoc.Title + "\r\n");
            var fm = doc.FamilyManager;
            var ft = fm.CurrentType; //��ȡ��ǰ����
            DataTable dt = new();
            dt.Columns.Add("������", typeof(string));
            dt.Columns.Add("����", typeof(string));
            dt.Columns.Add("����ֵ", typeof(string));
            dt.Columns.Add("��ʽ", typeof(string));
            if (ft == null)
            {
                //IList<FamilyParameter> faparas = fm.GetParameters();
                //foreach (var para in faparas)
                //{
                //    sb.Append(para.Definition.Name);
                //}
                using Transaction trans = new(doc);
                trans.Start("�½�������");
                var NT = "NewType";
                ft = fm.NewType(NT);
                trans.Commit();
            }

            List<BuiltInParameterGroup> pgs = [];
            foreach (FamilyParameter para in fm.Parameters)
            {
                if (!pgs.Contains(para.Definition.ParameterGroup))
                {
                    pgs.Add(para.Definition.ParameterGroup);
                }
            }

            foreach (var pg in pgs)
            {
                foreach (FamilyParameter para in fm.Parameters)
                {
                    if (para.Definition.ParameterGroup == pg)
                    {
                        var drpara = dt.NewRow();
                        drpara[0] = LabelUtils.GetLabelFor(pg);
                        drpara[1] = para.Definition.Name;
                        drpara[2] = ft.AsValueString(para);
                        drpara[3] = para.Formula;
                        dt.Rows.Add(drpara);
                    }
                }
            }

            return dt;
        }

        /// <summary>
        ///     ��ȡתJson�IJ�������
        /// </summary>
        /// <param name="doc"></param>
        /// <returns></returns>
        private Dictionary<string, Dictionary<string, JsonPara>> DictParas(Document doc)
        {
            var fm = doc.FamilyManager;
            var ft = fm.CurrentType; //��ȡ��ǰ����
            //���飬dir<����������������>
            Dictionary<string, Dictionary<string, JsonPara>> paragroups = [];
            using Transaction trans = new(doc);
            trans.Start("�½�������");
            ft ??= fm.NewType("NewType");
            List<BuiltInParameterGroup> pgs = [];
            foreach (FamilyParameter para in fm.Parameters)
            {
                if (!pgs.Contains(para.Definition.ParameterGroup))
                {
                    pgs.Add(para.Definition.ParameterGroup);
                }
            }

            foreach (var pg in pgs)
            {
                Dictionary<string, JsonPara> paras = [];

                foreach (FamilyParameter para in fm.Parameters)
                {
                    if (para.Definition.ParameterGroup == pg)
                    {
                        JsonPara JP = new() { Value = ft.AsValueString(para), Formula = para.Formula };
                        paras.Add(para.Definition.Name, JP);
                        //drpara[0] = para.Definition.Name;
                        //drpara[1] = ft.AsValueString(para);
                        //drpara[2] = para.Formula;
                    }
                }

                paragroups.Add(LabelUtils.GetLabelFor(pg), paras);
            }
            trans.RollBack();
            return paragroups;
        }

        private void DictionaryToJson(string fullName, Dictionary<string, Dictionary<string, JsonPara>> dicts, string DirChoosed)
        {
            //string filename = "";
            //try
            //{
            //    FileInfo file = new FileInfo(filename);
            //    string json = File.ReadAllText("config.json");
            //    dynamic jsonObj = Newtonsoft.Json.JsonConvert.DeserializeObject(json);
            //    //jsonObj["L_BPointMoveDelay"] = LBPointdelay.ToString();
            //    string output = Newtonsoft.Json.JsonConvert.SerializeObject(jsonObj, Newtonsoft.Json.Formatting.Indented);
            //    File.WriteAllText("config.json", output);
            //}
            //catch (Exception)
            //{

            //    throw;
            //}
            //string serverAppPath = Request.PhysicalApplicationPath.ToString();

            //��ȡ�ļ�����������·������չ����
            var safefilename = Path.GetFileNameWithoutExtension(fullName);
            //��������չ�����ļ�����·��+�ļ���
            //string JosnWithoutEx = DirChoosed + "\\" + safefilename + "\\" + safefilename + "-" + "������";
            //���ļ���������Ŀ¼���ļ�����Ŀ¼��
            var fileDir = Path.Combine(DirChoosed, safefilename);
            //�����ļ�������·����
            var file_fullpath = Path.Combine(DirChoosed, safefilename, $"{safefilename}.json");

            if (!Directory.Exists(fileDir))
            {
                Directory.CreateDirectory(fileDir);
            }

            if (!File.Exists(file_fullpath))
            {
                //File.Create(file_fullpath);
                var JsonString = JsonConvert.SerializeObject(dicts);
                File.WriteAllText(file_fullpath, JsonString);
            }

            //��ģ������д���ļ�
            //using (StreamWriter sw = new StreamWriter(file_fullpath))
            //{
            //    JsonSerializer serializer = new JsonSerializer();
            //    serializer.Converters.Add(new JavaScriptDateTimeConverter());
            //    serializer.NullValueHandling = NullValueHandling.Ignore;

            //    //����Json.net�����
            //    JsonWriter writer = new JsonTextWriter(sw);
            //    //��ģ���������л���д��Json.net��JsonWriter����
            //    serializer.Serialize(writer, lot);
            //    //ser.Serialize(writer, ht);
            //    writer.Close();
            //    sw.Close();
            //}
        }
        /// <summary>
        /// ������ѡ��
        /// </summary>
        /// <param name="saveDirChoosed"></param>
        /// <param name="filesFullPathChoosed"></param>
        /// <param name="famodc"></param>
        /// <param name="views"></param>
        /// <param name="forward"></param>
        private void ExportOption(string saveDirChoosed, string filesFullPathChoosed, Document famodc, IList<ElementId> views, XYZ forward)
        {
            var Imapath = Path.Combine(saveDirChoosed, Path.GetFileNameWithoutExtension(filesFullPathChoosed));
            var format = Properties.Settings.Default.ImgFormat;

            if (!Directory.Exists(Imapath))
            {
                Directory.CreateDirectory(Imapath);
            }

            ImageExportOptions options =
                new()
                {
                    FilePath = Path.Combine(Imapath, $"{forward}"),
                    FitDirection = FitDirectionType.Horizontal,
                    HLRandWFViewsFileType = (ImageFileType)Enum.Parse(typeof(ImageFileType), format),
                    //HLRandWFViewsFileType = ImageFileType.JPEGLossless,
                    //ShadowViewsFileType = (ImageFileType)Enum.Parse(typeof(ImageFileType), format),
                    ExportRange = ExportRange.SetOfViews,
                    ImageResolution = ImageResolution.DPI_600,
                    //ShouldCreateWebSite = false,
                    ZoomType = ZoomFitType.FitToPage,
                    PixelSize = int.Parse(Properties.Settings.Default.ImgSize)
                };

            //if (views.Count > 0)
            //{
            //    options.SetViewsAndSheets(views);
            //    options.ExportRange = ExportRange.SetOfViews;
            //}
            //else
            //{
            //    options.ExportRange = ExportRange
            //      .VisibleRegionOfCurrentView;
            //}
            options.SetViewsAndSheets(views);
            famodc.ExportImage(options);
        }

        private void ExportThumbnail(string saveDirChoosed, string filesFullPathChoosed, Document famdoc)
        {
            IList<ElementId> views = [];

            //FilteredElementCollector concol = new FilteredElementCollector(famdoc).QueryElementsByType(typeof(ConnectorElement)).OfCategory(BuiltInCategory.OST_ConnectorElem);

            //FilteredElementCollector dimcol = new FilteredElementCollector(famdoc).QueryElementsByType(typeof(Dimension)).OfCategory(BuiltInCategory.OST_Dimensions);

            var v3d = new FilteredElementCollector(famdoc)
                .OfClass(typeof(View))
                .OfCategory(BuiltInCategory.OST_Views)
                .OfType<View3D>()
                .FirstOrDefault(x => x.ViewType == ViewType.ThreeD);
            //ElementClassFilter dimcf = new ElementClassFilter(typeof(Dimension));
            //ElementClassFilter ardimcf = new ElementClassFilter(typeof(AngularDimension));
            //LogicalOrFilter orFilter = new LogicalOrFilter(dimcf, ardimcf);
            //    FilteredElementCollector dimcol = new FilteredElementCollector(famdoc).WherePasses(orFilter);
            //var viewFamilyType = new FilteredElementCollector(famdoc).QueryElementsByType(typeof(ViewFamilyType)).OfType<ViewFamilyType>().LastOrDefault(x => x.ViewFamily == ViewFamily.ThreeDimensional);
            //var viewFamilyTypes = new FilteredElementCollector(famdoc).QueryElementsByType(typeof(ViewFamilyType)).OfType<ViewFamilyType>().GetEnumerator();


            //var direction = new XYZ(-1, 1, -1);
            using Transaction trans = new(famdoc, "ExportImage");
            trans.Start();
            //XYZ eyep1 = new XYZ(1.66983442269142, -1.62882392400378, 6.75513625996179);
            //XYZ forwarddir1 = new XYZ(0.577350269189626, 0.577350269189626, -0.577350269189626);
            //XYZ updir1 = new XYZ(0.408248290463863, 0.408248290463863, 0.816496580927726);
            //ViewOrientation3D isometric1 = new ViewOrientation3D(eyep1, forwarddir1, updir1);

            //XYZ eyep2 = new XYZ(6.66133814775094E-15, 2.22788354954364, 4.88410451942765);
            //XYZ forwarddir2 = new XYZ(0, -1, 0);
            //XYZ updir2 = new XYZ(0, 0, 1);

            //ViewOrientation3D isometric2 = new ViewOrientation3D(eyep2, forwarddir2, updir2);
            //var coord = v3d.GetOrientation();

            var graphicDisplayOptions = v3d.get_Parameter(BuiltInParameter.MODEL_GRAPHICS_STYLE);
            graphicDisplayOptions.Set(8);
            var elemIds = new FilteredElementCollector(famdoc)
               .OfClass(typeof(ConnectorElement)).ToElementIds();
            var elemIds1 = new FilteredElementCollector(famdoc)
   .OfCategory(BuiltInCategory.OST_Dimensions).ToElementIds();
            v3d.HideElements(elemIds);
            v3d.HideElements(elemIds1);
            //ģ����ʾΪ�������
            //Options op = new Options();
            //op.DetailLevel = ViewDetailLevel.Fine;
            //op.View.DisplayStyle = DisplayStyle.Realistic;
            //famdoc.ActiveView = v3d;
            views.Add(v3d.Id);
            trans.Commit();
            //v3d.SetOrientation(new ViewOrientation3D(new XYZ(-1, 1, -1), new XYZ(0, 1, 1), new XYZ(0, 1, -1)));
            XYZ forward = new(-1, 1, -1);
            v3d.OrientTo(forward);
            ExportOption(saveDirChoosed, filesFullPathChoosed, famdoc, views, forward);
            //v3d.OrientTo(new XYZ(0, -1, 0));
            //ExportOption(ps, saveDirChoosed, filesFullPathChoosed, famdoc, views);


            #region MyRegion

            //while (viewFamilyTypes.MoveNext()) //һ��Ҫ��movenext,��Ȼ�����쳣
            //{
            //    if (viewFamilyTypes.Current.ViewFamily == ViewFamily.ThreeDimensional)
            //    {
            //        var view3D = View3D.CreateIsometric(famdoc, viewFamilyTypes.Current.Id);

            //        //var view3D = (viewFamilyType != null) ? View3D.CreateIsometric(famdoc, viewFamilyType.Id) : null;

            //        //var viewer = view3D.GetOrientation();
            //        if (view3D != null)
            //        {
            //            if (concol != null)
            //            {
            //                famdoc.Delete(concol.ToElementIds());
            //                //famdoc.Delete(dimcol.ToElementIds());
            //            }
            //            if (dimcol != null)
            //            {
            //                foreach (Dimension dim in dimcol.ToElements())
            //                {
            //                    if (dim.ValueString != null)
            //                    {
            //                        //System.Diagnostics.Debug.WriteLine(dim.Id);
            //                        try
            //                        {
            //                            famdoc.Delete(dim.Id);
            //                        }
            //                        catch (Exception)
            //                        {
            //                            //System.Diagnostics.Debug.WriteLine(dim.Id);
            //                        }
            //                    }
            //                }
            //            }
            //            views.Add(view3D.Id);
            //            var graphicDisplayOptions
            //              = view3D.get_Parameter(
            //                BuiltInParameter.MODEL_GRAPHICS_STYLE);
            //            //ģ����ʾΪ�������

            //            graphicDisplayOptions.Set(6);
            //        }
            //    }
            //}

            #endregion

            forward = new XYZ(1, -1, -1);
            v3d.OrientTo(forward);
            ExportOption(saveDirChoosed, filesFullPathChoosed, famdoc, views, forward);

            forward = new XYZ(0, 1, 0);
            v3d.OrientTo(forward);
            ExportOption(saveDirChoosed, filesFullPathChoosed, famdoc, views, forward);
            //ExportOption(ps, saveDirChoosed, filesFullPathChoosed, famdoc, views);
        }
        //private  void TableToExcel(string fullName, DataTable dt, string DirChoosed)
        //{
        //    IWorkbook workbook;
        //    Configuration config = new Configuration();
        //    //��ȡ�ļ�����������·������չ����
        //    string safefilename = Path.GetFileNameWithoutExtension(fullName);
        //    //��������չ��������·��
        //    string ExcelWithoutEx = DirChoosed + "\\" + safefilename + "\\" + safefilename + "-" + "������";
        //    //���ļ���������Ŀ¼���ļ�����Ŀ¼��
        //    string fileDir = DirChoosed + "\\" + safefilename + "\\";
        //    //����Ŀ¼
        //    DirectoryInfo fileDirInfo = new DirectoryInfo(fileDir);
        //    if (!fileDirInfo.Exists)
        //    {
        //        fileDirInfo.Create();
        //    }
        //    string filename = null;
        //    string ver = config.GetConfig(Selection.ExcelVersion);

        //    //if (ver == "Excel ������(*.xlsx)")
        //    //{

        //    //    workbook = new XSSFWorkbook();
        //    //    filename = ExcelWithoutEx + ".xlsx";

        //    //}
        //    if (ver == "Excel 97-2003 ������(*.xls)")
        //    {
        //        workbook = new HSSFWorkbook();
        //        filename = ExcelWithoutEx + ".xls";
        //    }
        //    else
        //    {
        //        workbook = null;
        //    }
        //    //using (FileStream fileStream = new FileStream(fileName, FileMode.Open, FileAccess.Read))
        //    //{
        //    //    //�Զ����ݶ�ȡ���ı��汾����2007����2003�湤��book
        //    //    workbook = WorkbookFactory.Create(fileName);
        //    //    fileStream.Close();
        //    //}
        //    if (workbook == null)
        //    {
        //        return;
        //    }
        //    ISheet sheet = string.IsNullOrEmpty(dt.TableName) ? workbook.CreateSheet("������") : workbook.CreateSheet(dt.TableName);

        //    ICellStyle style = workbook.CreateCellStyle();
        //    //style.BorderRight = NPOI.SS.UserModel.BorderStyle.Thin;
        //    //style.BorderLeft = NPOI.SS.UserModel.BorderStyle.Thin;
        //    //style.BorderTop = NPOI.SS.UserModel.BorderStyle.Thin;
        //    //style.BorderBottom = NPOI.SS.UserModel.BorderStyle.Thin;
        //    IFont font = workbook.CreateFont();
        //    font.FontHeightInPoints = 14;
        //    //font.Boldweight = (short)NPOI.SS.UserModel.FontBoldWeight.Bold;
        //    font.FontName = "����";
        //    style.SetFont(font);//HEAD ��ʽ

        //    //��ͷ
        //    IRow row = sheet.CreateRow(0);
        //    for (int i = 0; i < dt.Columns.Count; i++)
        //    {
        //        //ICellStyle ics = workbook.CreateCellStyle();
        //        //ics.FillPattern = NPOI.SS.UserModel.FillPattern.SolidForeground;
        //        //cell.CellStyle = ics;
        //        ICell cell = row.CreateCell(i);

        //        cell.SetCellValue(dt.Columns[i].ColumnName);
        //    }

        //    //����
        //    for (int i = 0; i < dt.Rows.Count; i++)
        //    {
        //        IRow row1 = sheet.CreateRow(i + 1);
        //        for (int j = 0; j < dt.Columns.Count; j++)
        //        {

        //            ICell cell = row1.CreateCell(j);
        //            if (dt.Rows[i][0].ToString() == "")
        //            {
        //                cell.CellStyle = style;
        //                //IFont f = workbook.CreateFont();
        //                //f.FontHeightInPoints = 14;
        //                //cell.CellStyle.SetFont(f);
        //            }
        //            cell.SetCellValue(dt.Rows[i][j].ToString());
        //        }
        //    }

        //    //תΪ�ֽ�����
        //    MemoryStream stream = new MemoryStream();
        //    workbook.Write(stream);
        //    var buf = stream.ToArray();
        //    FileInfo file = new FileInfo(filename);
        //    //����ΪExcel�ļ�
        //    using (FileStream fs = new FileStream(filename, FileMode.Create, FileAccess.Write))
        //    {

        //        fs.Write(buf, 0, buf.Length);
        //        fs.Flush();
        //    }
        //}

        //foreach (Autodesk.Revit.DB.View view in views)
        //{
        //    //if (view.IsTemplate) continue;
        //    if (view.ViewType == ViewType.ThreeD)
        //    {
        //        Transaction trans = new Transaction(famdoc, "Export Image");
        //        trans.Start();
        //        if (concol!=null)
        //        {
        //            famdoc.Delete(concol.ToElementIds());
        //        }
        //        var graphicDisplayOptions = view.get_Parameter(BuiltInParameter.MODEL_GRAPHICS_STYLE);
        //        graphicDisplayOptions.Set(6);
        //        trans.Commit();
        //        ImageExportList.Add(view.Id);
        //    }
        //}
        //string directroy = Path.GetDirectoryName(path) +"\\"+;
    }
}