using Eplan.EplApi.MasterData;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;
using KPlan.Util;
using System.Collections.ObjectModel;
using ModelObject = Teamcenter.Soa.Client.Model.ModelObject;

namespace KPlan.Forms {
   /// <summary>
   /// Interaction logic for PartSync.xaml
   /// </summary>
   public partial class PartSync : Window {

      public const string NOT_RELEASEED = "未发布";
      public const string NOT_SYNCED = "未同步";

      private MDPartsDatabase mdPartsDatabase;

      private KBackgroundWorker bgWorker_Parts;
      private KBackgroundWorker bgWorker_AddAll;
      private KBackgroundWorker bgWorker_Query;
      private KBackgroundWorker bgWorker_Query_TC;
      private KBackgroundWorker bgWorker_EPlan_to_TC;
      private KBackgroundWorker bgWorker_TC_to_EPlan;
      private KBackgroundWorker bgWorker_Revise;
      private KBackgroundWorker bgWorker_UploadPartsDB;
      private KBackgroundWorker bgWorker_SyncErpCode;
      private int sync_Success = 0;
      //private MDPart[] allParts;
      private Dictionary<MDPartsDatabaseItem.Enums.ProductTopGroup, EPlanGroup> topGroupMap = new Dictionary<MDPartsDatabaseItem.Enums.ProductTopGroup, EPlanGroup>();
      private ObservableCollection<PartSyncDataRow> ePlanToTCData = new ObservableCollection<PartSyncDataRow>();
      private ObservableCollection<PartSyncDataRow> tcToEPlanData = new ObservableCollection<PartSyncDataRow>();
      private ObservableCollection<SyncResult> errData = new ObservableCollection<SyncResult>();
      private class EPlanGroup {
         public EPlanTreeItem topGroup { get; set; }
         public EPlanGroup(EPlanTreeItem topGroup) {
            this.topGroup = topGroup;
         }

         public Dictionary<MDPartsDatabaseItem.Enums.ProductGroup, EPlanTreeItem> productGroupMap = new Dictionary<MDPartsDatabaseItem.Enums.ProductGroup, EPlanTreeItem>();
      }

      

      public PartSync(MDPartsDatabase mdPartsDatabase) {
         InitializeComponent();
         this.mdPartsDatabase = mdPartsDatabase;
         bgWorker_Parts = new KBackgroundWorker(this);
         bgWorker_Parts.backgroundWorker.DoWork += Async_LoadParts;
         bgWorker_AddAll = new KBackgroundWorker(this);
         bgWorker_AddAll.backgroundWorker.DoWork += Async_AddAllUnsyncedParts;
         bgWorker_Query = new KBackgroundWorker(this);
         bgWorker_Query.backgroundWorker.DoWork += Async_QueryParts;
         bgWorker_EPlan_to_TC = new KBackgroundWorker(this);
         bgWorker_EPlan_to_TC.backgroundWorker.DoWork += Async_EPlan_to_TC;
         bgWorker_EPlan_to_TC.backgroundWorker.RunWorkerCompleted += bgWorker_EPlan_to_TC_RunWorkerCompleted;
         bgWorker_TC_to_EPlan = new KBackgroundWorker(this);
         bgWorker_TC_to_EPlan.backgroundWorker.DoWork += Async_TC_to_EPlan;
         bgWorker_TC_to_EPlan.backgroundWorker.RunWorkerCompleted += bgWorker_EPlan_to_TC_RunWorkerCompleted;

         bgWorker_Revise = new KBackgroundWorker(this);
         bgWorker_Revise.backgroundWorker.DoWork += Async_Revise;
         bgWorker_Query_TC = new KBackgroundWorker(this);
         bgWorker_Query_TC.backgroundWorker.DoWork += Async_QueryTCParts;

         bgWorker_UploadPartsDB = new KBackgroundWorker(this);
         bgWorker_UploadPartsDB.backgroundWorker.DoWork += Async_UploadPartsDB;
         bgWorker_SyncErpCode = new KBackgroundWorker(this);
         bgWorker_SyncErpCode.backgroundWorker.DoWork += Async_SyncErpCode;


         table_Sync_To_TC.ItemsSource = ePlanToTCData;
         table_Sync_To_EPLAN.ItemsSource = tcToEPlanData;
         TCUtil.DO_NOTHING();
         //Init_TreeGroups();
         //allParts = EplanUtil.mdPartsDatabase.Parts;
      }

      private void Async_SyncErpCode(object sender, DoWorkEventArgs e) {
         KUtil.Log("开始执行：同步ERP编码");
         bgWorker_SyncErpCode.Progress("查询EPLAN数据...", 0);
         MDPart[] parts =  EplanUtil.QueryParts(null, "");
         int len = parts == null ? 0 : parts.Length;
         KUtil.Log("查询结果数量："+len);
         if (len == 0) {
            return;
         }
         Dictionary<string, string> orderNr_itemId = new Dictionary<string, string>();
         for(int i = 0; i < len; i++) {
            if (bgWorker_SyncErpCode.IsCancel()) {
               e.Cancel = true;
               return;
            }
            MDPart part = parts[i];
            string orderNr = EplanUtil.GetMDPropValue(part.Properties.ARTICLE_PARTNR);
            KUtil.Log((i+1)+". 检查部件：" + part.PartNr+"|"+orderNr);
            bgWorker_SyncErpCode.Progress("同步数据...( " + (i + 1) + " / " + len + " )", (i + 1) * 100 / len);
            if (!KUtil.IsEmpty(orderNr)) {
               string itemId = "";
               if (orderNr_itemId.ContainsKey(orderNr)) {
                  itemId = orderNr_itemId[orderNr];
               }
               else {
                  Teamcenter.Soa.Client.Model.Strong.ItemRevision rev = TCUtil.Query_LatestRevByOrderNr_single(orderNr);
                  if (rev != null) {
                     ModelObject[] mos = TCUtil.Refresh(rev);
                     TCUtil.GetProperties(false, mos, "item_id");
                     itemId = rev.Item_id;
                  }
                  orderNr_itemId.Add(orderNr, itemId);
               }
               KUtil.Log(">> 设置ERPNumber = "+itemId);
               //写入ERPNumber
               MDPartsDatabaseTransaction trans = mdPartsDatabase.CreateTransaction();
               part.Properties.ARTICLE_ERPNR = itemId;
               trans.Commit();
               trans.Dispose();
            }
         }
         KUtil.Log("执行结束");
         MessageBox.Show(this, "同步完成");
      }

      private void Async_UploadPartsDB(object sender, DoWorkEventArgs e) {
         bgWorker_UploadPartsDB.Progress("准备上传EPLAN数据...", 0);
         string fmsHome = Environment.GetEnvironmentVariable("FMS_HOME");
         string zipFile = fmsHome + "\\EPlan\\" + "EPLAN_PARTS.zip";
         string eplanDataFolderPath = KUtil.GetConfigValue(KConfigure.EPLAN_DATA_SECTION, KConfigure.EPLAN_DATA_FOLDER);
         string skipFolders = KUtil.GetConfigValue(KConfigure.EPLAN_DATA_SECTION, KConfigure.EPLAN_DATA_SKIP_FOLDER);
         string dsUid = KUtil.GetConfigValue(KConfigure.EPLAN_DATA_SECTION, KConfigure.EPLAN_DATASET_UID);
         if (KUtil.IsEmpty(eplanDataFolderPath)) {
            throw new Exception("未配置EPLAN数据文件夹");
         }
         if (KUtil.IsEmpty(dsUid)) {
            throw new Exception("未配置TC数据集UID");
         }
         if (!System.IO.Directory.Exists(eplanDataFolderPath)) {
            throw new Exception("EPLAN数据文件夹不存在，请检查配置：" + eplanDataFolderPath);
         }
         KUtil.Log("准备上传EPLAN数据文件夹：" + eplanDataFolderPath);
         ModelObject mo = TCUtil.StringToComponent(dsUid);
         if (mo == null) {
            throw new Exception("未查询到数据集 uid = "+dsUid+"，请检查配置");
         }
         ModelObject[] mos = TCUtil.Refresh(mo);
         TCUtil.GetProperties(false, mos, "object_string");
         string dsName = mo.GetPropertyDisplayableValue("object_string");
         KUtil.Log("找到数据集：" + dsName);
         if (!TCUtil.IsType(mo.SoaType, "Zip")) {
            throw new Exception("配置的数据集<" + dsName + ">不是Zip数据集，uid = " + dsUid);
         }
         this.bgWorker_UploadPartsDB.Progress("压缩目录...",30);
         if (!KUtil.ZipDirectory(eplanDataFolderPath, zipFile, null, skipFolders)) {
            throw new Exception("压缩EPLAN部件库失败");
         }
         KUtil.Log("压缩完成");
         this.bgWorker_UploadPartsDB.Progress("上传文件...", 70);
         TCUtil.UploadFile((Teamcenter.Soa.Client.Model.Strong.Dataset)mo, zipFile, "ZIPFILE");
         KUtil.Log("上传成功");
         this.Dispatcher.Invoke(new Action(delegate {
            MessageBox.Show(this, "上传成功");
         }));
      }

      private void Async_Revise(object sender, DoWorkEventArgs e) {
         List<PartSyncDataRow> reviseList = e.Argument as List<PartSyncDataRow>;
         if (reviseList.Count == 0) {
            return;
         }
         bgWorker_Revise.Progress("正在升版...",0);
         int len = reviseList.Count;
         for(int i = 0; i < len; i++) {
            if (bgWorker_Revise.IsCancel()) {
               e.Cancel = true;
               return;
            }
            bgWorker_Revise.Progress("正在升版...( "+(i+1)+" / "+len+" )", (i+1)*100/len);
            PartSyncDataRow bean = reviseList[i];
            Teamcenter.Soa.Client.Model.Strong.ItemRevision newRev = TCUtil.Revise(bean.tcRev);
            if (newRev == null) {
               throw new Exception("对象升版失败："+bean.itemID);
            }
            Teamcenter.Soa.Client.Model.ModelObject[] mo = TCUtil.Refresh(newRev);
            TCUtil.GetProperties(false, mo, "item_revision_id");
            MDPartsDatabaseTransaction trans = mdPartsDatabase.CreateTransaction();
            bean.part.Properties.ARTICLE_CERTIFICATE_ATEX = "";
            trans.Commit();
            trans.Dispose();
            this.Dispatcher.Invoke(new Action(delegate {
               bean.itemRev = newRev.Item_revision_id;
               bean.releaseStatus = NOT_RELEASEED;
               bean.syncStatus = NOT_SYNCED;
               table_Sync_To_TC.Items.Refresh();
            }));
         }
      }

      private void Async_TC_to_EPlan(object sender, DoWorkEventArgs e) {
         sync_Success = 0;
         this.Dispatcher.Invoke(new Action(delegate {
            errData.Clear();
         }));
         bgWorker_TC_to_EPlan.Progress("执行中...", 0);
         int len = 0;
         this.Dispatcher.Invoke(new Action(delegate {
            len = tcToEPlanData.Count;
         }));
         for (int i = 0; i < len; i++) {
            if (bgWorker_TC_to_EPlan.IsCancel()) {
               e.Cancel = true;
               return;
            }
            bgWorker_TC_to_EPlan.Progress("执行中...( " + (i + 1) + " / " + len + " )", (i + 1) * 100 / len);
            PartSyncDataRow bean = tcToEPlanData[i];
            string errMsg = null;
            try {
               errMsg = Item_to_EPlan(bean);
            }
            catch (System.Exception ex) {
               KUtil.LogErr(ex);
               errMsg = ex.Message;
            }
            if (KUtil.IsEmpty(errMsg)) {
               sync_Success++;
            }
            else {
               if (!"已同步".Equals(errMsg)) {
                  this.Dispatcher.Invoke(new Action(delegate {
                     errData.Add(new SyncResult(null) { partNr = bean.partNr, name = bean.name, reason = errMsg });
                  }));
               }
            }
         }
      }

      private void Async_EPlan_to_TC(object sender, DoWorkEventArgs e) {

         sync_Success = 0;
         this.Dispatcher.Invoke(new Action(delegate {
            errData.Clear();
         }));
         bgWorker_EPlan_to_TC.Progress("执行中...",0);
         int len =0;
         this.Dispatcher.Invoke(new Action(delegate {
            len = ePlanToTCData.Count;
         }));
         for (int i = 0; i < len; i++) {
            if (bgWorker_EPlan_to_TC.IsCancel()) {
               e.Cancel = true;
               return;
            }
            bgWorker_EPlan_to_TC.Progress("执行中...( " + (i + 1) + " / " + len + " )", (i + 1) * 100 / len);
            PartSyncDataRow bean = ePlanToTCData[i];
            string errMsg = null;
            try {
               errMsg = Part_to_TC(bean);
            }
            catch (System.Exception ex) {
               KUtil.LogErr(ex);
               errMsg = ex.Message;
            }
            if (KUtil.IsEmpty(errMsg)) {
               sync_Success++;
            }
            else {
               if (!"已同步".Equals(errMsg)) {
                  this.Dispatcher.Invoke(new Action(delegate {
                     errData.Add(new SyncResult(null) { partNr = bean.partNr, name = bean.name, reason = errMsg });
                  }));
               }
            }
         }
         //this.Dispatcher.Invoke(new Action(delegate{
         //   new PartSyncResult(this, sync_Success, ePlanToTCData.Count - sync_Success - errData.Count, errData).ShowDialog();
         //}));
      }

      private void bgWorker_EPlan_to_TC_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e) {
         if (e.Error == null) {
            new PartSyncResult(mdPartsDatabase, this, sync_Success, ePlanToTCData.Count - sync_Success - errData.Count, errData).ShowDialog();
            //else {
            //   MessageBox.Show(parent, "操作完成");
            //}
         }
      }

      private String Item_to_EPlan(PartSyncDataRow bean) {
         Teamcenter.Soa.Client.Model.Strong.ItemRevision rev = bean.tcRev;
         MDPart part = bean.part;
         if (part == null) {
            return "部件不存在";
         }
         //同步属性到EPlan
         KUtil.Sync_Property_to_EPlan(mdPartsDatabase, rev, bean.part);
         return "";
      }

      private string Part_to_TC(PartSyncDataRow bean) {
         string errMsg = null;
         string releaseStatus = bean.releaseStatus;
         string syncStatus = bean.syncStatus;
         Teamcenter.Soa.Client.Model.Strong.ItemRevision rev = null;
         switch (syncStatus) {
            case NOT_SYNCED:
               if (NOT_RELEASEED.Equals(releaseStatus)) {
                  //通过item获取对象
                  rev = TCUtil.Query_LatestRev(bean.itemID);
                  if (rev == null) {
                     errMsg = "未查询到对象：" + bean.itemID;
                  }
               }
               else {
                  //失败：未升版
                  errMsg = "未升版";
               }
               break;
            case "新增":
               //新建对象 反写ID
               string tcItemType = KUtil.GetConfigValue(KConfigure.PART_SYNC_SECTION, KConfigure.PART_SYNC_TC_ITEM_TYPE);
               if (KUtil.IsEmpty(tcItemType)) {
                  throw new Exception("未配置TC数据类型");
               }
               rev = TCUtil.CreateNewRev(tcItemType);
               if (rev == null) {
                  errMsg = "新建对象失败";
               }
               //else {
               //   Teamcenter.Soa.Client.Model.ModelObject[] mo = TCUtil.Refresh(rev);
               //   TCUtil.GetProperties(false, mo, "item_id","item_revision_id","object_name");
               //   MDPartsDatabaseTransaction trans = EplanUtil.mdPartsDatabase.CreateTransaction();
               //   bean.part.Properties.ARTICLE_ERPNR = rev.Item_id;
               //   trans.Commit();
               //   trans.Dispose();
               //   this.Dispatcher.Invoke(new Action(delegate {
               //      bean.itemID = rev.Item_id;
               //      bean.itemRev = rev.Item_revision_id;
               //      bean.itemName = rev.Object_name;
               //      table_Sync_To_TC.Items.Refresh();
               //   }));
               //}
               break;
            case "SAP未分配ID":
               //失败：
               errMsg = "SAP未分配ID";
               break;
            case "已同步":
               return "已同步";
            default:
               //失败：未知状态
               errMsg = "未知同步状态：" + syncStatus;
               break;
         }
         if (KUtil.IsEmpty(errMsg)) {
            if (rev == null) {
               errMsg = "获取TC对象异常";
            }
            else {
               //属性同步 发送分类
               KUtil.Sync_Property_to_TC(rev, bean.part);
               Teamcenter.Soa.Client.Model.ModelObject[] mo = TCUtil.Refresh(rev);
               TCUtil.GetProperties(false, mo, "item_id", "item_revision_id", "object_name");
               MDPartsDatabaseTransaction trans = mdPartsDatabase.CreateTransaction();
               bean.part.Properties.ARTICLE_ERPNR = rev.Item_id;
               bean.part.Properties.ARTICLE_CERTIFICATE_ATEX = "已同步";
               trans.Commit();
               trans.Dispose();
               this.Dispatcher.Invoke(new Action(delegate {
                  bean.itemID = rev.Item_id;
                  bean.itemRev = rev.Item_revision_id;
                  bean.itemName = rev.Object_name;
                  bean.syncStatus = "已同步";
                  table_Sync_To_TC.Items.Refresh();
               }));
            }
         }
         return errMsg;
      }



      

      private void Async_QueryTCParts(object sender, DoWorkEventArgs e) {
         string partNr = "";
         string itemId = "";
         this.Dispatcher.Invoke(new Action(delegate {
            partNr = tb_PartNr_TC.Text;
            itemId = tb_ItemID_TC.Text;
         }));
         string queryName = KUtil.GetConfigValue(KConfigure.PART_QUERY_SECTION, KConfigure.PART_QUERY_NAME);
         string itemField = KUtil.GetConfigValue(KConfigure.PART_QUERY_SECTION, KConfigure.PART_QUERY_ITEM_ID);
         string partField = KUtil.GetConfigValue(KConfigure.PART_QUERY_SECTION, KConfigure.PART_QUERY_ORDERNR);
         if (KUtil.IsEmpty(queryName) || KUtil.IsEmpty(itemField) || KUtil.IsEmpty(partField)) {
            throw new Exception("TC部件查询配置缺失，请检查设置");
         }
         string partNrProp = KUtil.GetConfigValue(KConfigure.PART_SYNC_SECTION, KConfigure.PART_SYNC_OrderNr_TC);
         if (KUtil.IsEmpty(partNrProp)) {
            throw new Exception("未配置部件编号在TC中的属性");
         }
         Dictionary<string, string> fields = new Dictionary<string, string>();
         if (!KUtil.IsEmpty(itemId)) {
            fields.Add(itemField, itemId);
         }
         if (!KUtil.IsEmpty(partNr)) {
            fields.Add(partField, partNr);
         }
         if (fields.Count == 0) {
            MessageBox.Show(this, "请输入查询条件");
            return;
         }
         KUtil.Log("查询部件：PartNR = " + partNr + ", ErpNR = " + itemId);
         bgWorker_Query_TC.Progress("查询中...",0);
         ModelObject[] unsyncItems = TCUtil.query(queryName, fields);
         int len = unsyncItems == null ? 0 : unsyncItems.Length;
         KUtil.Log("查询结果数量：" + len);
         for (int i = 0; i < len; i++) {
            if (bgWorker_Query_TC.IsCancel()) {
               e.Cancel = true;
               return;
            }
            bgWorker_Query_TC.Progress("加载数据...( " + (i + 1) + " / " + len + " )", (i + 1) * 100 / len);
            ModelObject rev = unsyncItems[i];
            ModelObject[] mo = TCUtil.Refresh(rev);
            TCUtil.GetProperties(false, mo, "object_string");
            if (!TCUtil.IsType(rev.SoaType, "ItemRevision")) {
               throw new Exception("获取配置属性失败，对象不是版本类型：" + rev.GetPropertyDisplayableValue("object_string"));
            }
            Add_Sync_Data((Teamcenter.Soa.Client.Model.Strong.ItemRevision)rev, partNrProp);
         }
      }

      private void Async_QueryParts(object sender, DoWorkEventArgs e) {
         string partNr = "";
         string erpNr = "";
         this.Dispatcher.Invoke(new Action(delegate {
            partNr = tb_PartNr.Text;
            erpNr = tb_ERPNr.Text;
         }));
         KUtil.Log("查询部件：PartNR = " + partNr + ", ErpNR = " + erpNr);
         bgWorker_Query.Progress("查询中...", 0);
         MDPart[] unsyncParts = EplanUtil.QueryParts(mdPartsDatabase, partNr, erpNr);
         int len = unsyncParts == null ? 0 : unsyncParts.Length;
         KUtil.Log("查询结果数量：" + len);
         for (int i = 0; i < len; i++) {
            if (bgWorker_Query.IsCancel()) {
               e.Cancel = true;
               return;
            }
            bgWorker_Query.Progress("加载数据...( " + (i + 1) + " / " + len + " )", (i + 1) * 100 / len);
            Add_Sync_Data(unsyncParts[i], false);
         }
      }

      private void Async_AddAllUnsyncedParts(object sender, DoWorkEventArgs e) {
         string partNr = "";
         string erpNr = "";
         this.Dispatcher.Invoke(new Action(delegate {
            partNr = tb_PartNr.Text;
            erpNr = tb_ERPNr.Text;
         }));
         KUtil.Log("查询未同步部件：PartNR = " + partNr + ", ErpNR = " + erpNr);
         bgWorker_AddAll.Progress("查询中...", 0);
         List<MDPart> unsyncParts = EplanUtil.GetUnsyncedParts(mdPartsDatabase, partNr, erpNr);
         int len = unsyncParts == null? 0 :unsyncParts.Count;
         KUtil.Log("查询全部未同步部件数量："+len);
         for(int i = 0; i < len; i++) {
            if (bgWorker_AddAll.IsCancel()) {
               e.Cancel = true;
               return;
            }
            bgWorker_AddAll.Progress("加载数据...( "+(i+1)+" / "+len+" )",(i+1)*100/len);
            Add_Sync_Data(unsyncParts[i], false);
         }
      }

      private void Async_LoadParts(object sender, DoWorkEventArgs e) {
         EPlanTreeItem parent = (EPlanTreeItem)e.Argument;
         if (parent != null) {
            Cycle_Home(parent, e);
            return;
         }
         //TreeViewItem node_home = null;
         bgWorker_Parts.Progress("加载数据...", 0);
         EPlanTreeItem tree_home = null;
         this.Dispatcher.Invoke(new Action(delegate {
            tree_home = new EPlanTreeItem("Parts");
            tree_Parts.Items.Add(tree_home);
         }));
         /*int len = allParts.Length;
         for (int i = 0; i < len; i++) {
            if (bgWorkder_Parts.IsCancel()) {
               e.Cancel = true;
               return;
            }
            bgWorkder_Parts.Progress("加载数据...( "+(i+1)+" / "+len+" )", (i + 1) * 100 / len);
            MDPart p = allParts[i];
            EPlanTreeItem groupItem = FindTreeItem(p.GenericProductGroup, p.ProductGroup, tree_home); 
            if (groupItem == null) {
               throw new Exception("获取组节点异常");
            }
            this.Dispatcher.Invoke(new Action(delegate {
               groupItem.Items.Add(new EPlanTreeItem(p));
            }));
         }
         this.Dispatcher.Invoke(new Action(delegate {
            foreach (EPlanGroup g in topGroupMap.Values) {
               g.topGroup.Items.SortDescriptions.Add(new SortDescription("Header", ListSortDirection.Ascending));
               g.topGroup.Items.Refresh();
            }
         }));*/
         //加载TOPGROUP
         Init_TopGroup(MDPartsDatabaseItem.Enums.ProductTopGroup.Electric, tree_home);
         Init_TopGroup(MDPartsDatabaseItem.Enums.ProductTopGroup.Mechanic, tree_home);
         Init_TopGroup(MDPartsDatabaseItem.Enums.ProductTopGroup.Fluid, tree_home);
         Init_TopGroup(MDPartsDatabaseItem.Enums.ProductTopGroup.Process, tree_home);
         Init_TopGroup(MDPartsDatabaseItem.Enums.ProductTopGroup.Invaild, tree_home);
         Init_TopGroup(MDPartsDatabaseItem.Enums.ProductTopGroup.Undefined, tree_home);
         this.Dispatcher.Invoke(new Action(delegate {
            tree_home.IsExpanded = true;
         }));
      }

      private EPlanTreeItem FindTreeItem(MDPartsDatabaseItem.Enums.ProductTopGroup topGroup,MDPartsDatabaseItem.Enums.ProductGroup group,EPlanTreeItem root) {
         EPlanGroup ePlanGroup = null;
         if (topGroupMap.ContainsKey(topGroup)) {
            ePlanGroup = topGroupMap[topGroup];
         }
         else {
            this.Dispatcher.Invoke(new Action(delegate {
               //string topGroupName = MDPartsDatabaseItem.GetProductTopGroupName(topGroup);
               EPlanTreeItem topGroupItem = new EPlanTreeItem(topGroup);
               ePlanGroup = new EPlanGroup(topGroupItem);
               root.Items.Add(topGroupItem);
               topGroupMap.Add(topGroup, ePlanGroup);
            }));
         }
         if (ePlanGroup == null) { return null; }
         if (ePlanGroup.productGroupMap.ContainsKey(group)) {
            return ePlanGroup.productGroupMap[group];
         }
         else {
            EPlanTreeItem groupItem = null;
            this.Dispatcher.Invoke(new Action(delegate {
               //string groupName = MDPartsDatabaseItem.GetProductGroupName(group);
               groupItem = new EPlanTreeItem(topGroup,group);
               ePlanGroup.topGroup.Items.Add(groupItem);
               ePlanGroup.productGroupMap.Add(group, groupItem);
            }));
            return groupItem;
         }
      }

      private void Init_TopGroup(MDPartsDatabaseItem.Enums.ProductTopGroup topGroup, EPlanTreeItem tree_home) {
         //if (!EplanUtil.TopGroupHasPart(topGroup)) {
         //   return;
         //}
         //string topGroupName = MDPartsDatabaseItem.GetProductTopGroupName(topGroup);
         EPlanTreeItem tree_TopGroup = null;
         this.Dispatcher.Invoke(new Action(delegate {
            tree_TopGroup = new EPlanTreeItem(topGroup);
            //KUtil.Log(tree_TopGroup.Header.ToString());
            tree_home.Items.Add(tree_TopGroup);
         }));
         //加载Group
         MDPartsDatabaseItem.Enums.ProductGroup[] groups = MDPartsDatabaseItem.GetAvailableProductGroups(topGroup);
         for (int i = 0; i < groups.Length; i++) {
            MDPartsDatabaseItem.Enums.ProductGroup group = groups[i];
            //if (!EplanUtil.GroupHasPart(topGroup, group)) {
            //   continue;
            //}
            this.Dispatcher.Invoke(new Action(delegate {
               EPlanTreeItem tree_Group = new EPlanTreeItem(topGroup, group);
               //KUtil.Log(">> " + tree_Group.Header.ToString());
               tree_TopGroup.Items.Add(tree_Group);
               tree_Group.Items.Add(new EPlanTreeItem());//展开加载标记
            }));
         }
         this.Dispatcher.Invoke(new Action(delegate {
            tree_TopGroup.Items.SortDescriptions.Add(new SortDescription("Header", ListSortDirection.Ascending));
            tree_TopGroup.Items.Refresh();
         }));
      }

      private void Cycle_Home(EPlanTreeItem treeItem, DoWorkEventArgs e) {
         bool flag = false;
         this.Dispatcher.Invoke(new Action(delegate {
            if (!(treeItem.Items.Count == 1 && ((EPlanTreeItem)treeItem.Items.GetItemAt(0)).isLoadMark)) {
               flag = true;
            }
         }));
         if (flag) { return; }
         int topGroupId = -404;
         int groupId = -404;
         string groupName="";
         this.Dispatcher.Invoke(new Action(delegate {
            treeItem.Items.Clear();
            EPlanTreeItem topGroupItem = (EPlanTreeItem)treeItem.Parent;
            KUtil.Log("查询："+topGroupItem.Header+"|" + treeItem.Header);
            topGroupId = topGroupItem.groupId;
            groupId = treeItem.groupId;
            groupName = treeItem.Header.ToString();
         }));
         if (topGroupId ==-404 && groupId == -404) {
            return;
         }
         bgWorker_Parts.Progress("查询中...",0);
         MDPart[] parts = EplanUtil.GetParts(mdPartsDatabase, topGroupId, groupId);
         int len = parts == null ? 0:parts.Length;
         for(int i = 0; i < len; i++) {
            if (bgWorker_Parts.IsCancel()) {
               e.Cancel = true;
               return;
            }
            bgWorker_Parts.Progress("加载数据...( " + (i + 1) + " / " + len + " )", (i + 1) * 100 / len);
            this.Dispatcher.Invoke(new Action(delegate {
               treeItem.Items.Add(new EPlanTreeItem(parts[i],groupName));
            }));
         }
         
         

         //string group = treeItem.Header as string;
         //MDPartsDatabaseItem.GetAvailableProductGroups

         //ModelObject parent = treeItem.mo;
         //ModelObject[] children = null;
         ////var t = parent.GetType();
         //SoaType soaType = parent.SoaType;
         //ModelObject[] mo = TCUtil.Refresh(parent);
         //if (TCUtil.IsType(soaType, "Folder")) {
         //   TCUtil.GetProperties(false, mo, "contents");
         //   children = ((Folder)parent).Contents;
         //}
         //else if (TCUtil.IsType(soaType, "Item") || TCUtil.IsType(soaType, "ItemRevision")) {
         //   children = TCUtil.GetChildFromPref(parent);
         //}
         //else if (TCUtil.IsType(soaType, "Dataset")) {
         //   children = null;
         //}
         //else {
         //   return;
         //}
         //if (children == null) {
         //   return;
         //}
         //if (bgWorker_Query.IsCancel()) {
         //   e.Cancel = true;
         //   return;
         //}
         //ItemCollection node_children = null;
         //this.Dispatcher.Invoke(new Action(delegate {
         //   node_children = treeItem.Items;
         //}));
         //int len = children.Length;
         //for (int i = 0; i < len; i++) {
         //   if (bgWorker_Query.IsCancel()) {
         //      e.Cancel = true;
         //      return;
         //   }
         //   bgWorker_Homer.Progress("加载中...( " + (i + 1) + " / " + len + " )", (i + 1) * 100 / len);
         //   ModelObject c = children[i];
         //   EPlanTreeItem node_child = null;
         //   this.Dispatcher.Invoke(new Action(delegate {
         //      node_child = new EPlanTreeItem(c);
         //      node_children.Add(node_child);
         //      node_child.Items.Add(new EPlanTreeItem(null));
         //   }));
         //}
      }

      private void Window_Loaded(object sender, RoutedEventArgs e) {
         bgWorker_Parts.Start(null);
      }

      private void Tree_Parts_Expanded(object sender, RoutedEventArgs e) {
         EPlanTreeItem item = e.OriginalSource as EPlanTreeItem;
         bgWorker_Parts.Start(item);
      }

      private void Table_Sync_To_TC_Loaded(object sender, RoutedEventArgs e) {

      }

      private void Add_Button_Click(object sender, RoutedEventArgs e) {
         EPlanTreeItem selectedItem = tree_Parts.SelectedItem as EPlanTreeItem;
         if (selectedItem == null || selectedItem.part==null) {
            return;
         }
         try {
            Add_Sync_Data(selectedItem.part,true);
         }
         catch(System.Exception ex) {
            KUtil.LogErr(ex);
            MessageBox.Show(this, "添加数据出错："+ex.Message);
         }
      }

      private void Add_Sync_Data(MDPart part,bool select) {
         string partNr = part.PartNr;
         string orderNr = EplanUtil.GetMDPropValue(part.Properties.ARTICLE_PARTNR);
         PartSyncDataRow b = new PartSyncDataRow() {
            partNr = partNr
         };
         bool flag = false;
         this.Dispatcher.Invoke(new Action(delegate {
            if (ePlanToTCData.Contains(b)) {
               if (select) {
                  table_Sync_To_TC.SelectedItem = b;
                  table_Sync_To_TC.ScrollIntoView(b);
               }
               flag = true;
               //MessageBox.Show(this,"已经添加过该对象");
               //return;
            }
         }));
         if (flag) { return; }
         Teamcenter.Soa.Client.Model.Strong.ItemRevision tcRev = TCUtil.Query_LatestRevByOrderNr_single(orderNr);
         string itemID = "";
         string itemRev = "";
         string itemName = "";
         string releaseStatus = "";
         if (tcRev != null) {
            Teamcenter.Soa.Client.Model.ModelObject[] mo = TCUtil.Refresh(tcRev);
            TCUtil.GetProperties(false, mo, "item_id", "item_revision_id","object_name","release_status_list");
            itemID = tcRev.Item_id;
            itemRev = tcRev.Item_revision_id;
            itemName = tcRev.Object_name;
            Teamcenter.Soa.Client.Model.Strong.ReleaseStatus[] releaseList = tcRev.Release_status_list;
            TCUtil.GetProperties(false, releaseList, "name");
            for (int i = 0; i < releaseList.Length; i++) {
               releaseStatus += releaseList[i].Name;
               if (i != releaseList.Length - 1) {
                  releaseStatus += ", ";
               }
            }
         }
         if (KUtil.IsEmpty(releaseStatus)) {
            releaseStatus = NOT_RELEASEED;
         }
         string type = EplanUtil.GetMDPropValue(part.Properties.ARTICLE_MANUFACTURER,EplanUtil.Language).Trim();
         string syncStatus = GetSyncStatus(EplanUtil.GetMDPropValue(part.Properties.ARTICLE_CERTIFICATE_ATEX,EplanUtil.Language), type, itemID);
         b.index = ePlanToTCData.Count + 1 ;
         b.name = EplanUtil.GetMDPropValue(part.Properties.ARTICLE_DESCR1,EplanUtil.Language);
         b.itemID = itemID;
         b.itemName = itemName;
         b.itemRev = itemRev;
         b.type = type;
         b.releaseStatus = releaseStatus;
         b.syncStatus = syncStatus;
         b.part = part;
         b.tcRev = tcRev;
         this.Dispatcher.Invoke(new Action(delegate {
            ePlanToTCData.Add(b);
            table_Sync_To_TC.ScrollIntoView(b);
         }));
      }

      private void Add_Sync_Data(Teamcenter.Soa.Client.Model.Strong.ItemRevision rev, string partNrConfig) {
         ModelObject[] mo = TCUtil.Refresh(rev);
         TCUtil.GetProperties(false, mo, "item_id","item_revision_id", "release_status_list","object_string");
         string partNr = TCUtil.GetRevConfigProp(rev, partNrConfig);
         PartSyncDataRow b = new PartSyncDataRow() {
            partNr = partNr
         };
         if (!KUtil.IsEmpty(partNr) && tcToEPlanData.Contains(b)) {
            this.Dispatcher.Invoke(new Action(delegate {
               table_Sync_To_EPLAN.SelectedItem = b;
               table_Sync_To_EPLAN.ScrollIntoView(b);
            }));
            throw new Exception("无法添加对象“"+rev.Object_string+"”，部件编号为<" + partNr + ">的对象已添加，请检查查询条件或处理数据后再进行操作");
         }
         string itemID = rev.Item_id;
         string itemRev = rev.Item_revision_id;
         string itemName = rev.Object_name;
         string releaseStatus = "";
         Teamcenter.Soa.Client.Model.Strong.ReleaseStatus[] releaseList = rev.Release_status_list;
         TCUtil.GetProperties(false, releaseList, "name");
         for (int i = 0; i < releaseList.Length; i++) {
            releaseStatus += releaseList[i].Name;
            if (i != releaseList.Length - 1) {
               releaseStatus += ", ";
            }
         }
         if (KUtil.IsEmpty(releaseStatus)) {
            releaseStatus = NOT_RELEASEED;
         }
         MDPart part = null;
         string type = "";
         string syncStatus = "";
         string name = "";
         if (!KUtil.IsEmpty(partNr)) {
            part = EplanUtil.GetPart(mdPartsDatabase, partNr);
            if (part != null) {
               type = EplanUtil.GetMDPropValue(part.Properties.ARTICLE_MANUFACTURER,EplanUtil.Language).Trim();
               string erpNr = EplanUtil.GetMDPropValue(part.Properties.ARTICLE_ERPNR);
               syncStatus = GetSyncStatus(EplanUtil.GetMDPropValue(part.Properties.ARTICLE_CERTIFICATE_ATEX,EplanUtil.Language), type, erpNr);
               name = EplanUtil.GetMDPropValue(part.Properties.ARTICLE_DESCR1,EplanUtil.Language);
            }
         }
         b.index = tcToEPlanData.Count + 1 ;
         b.name = name;
         b.itemID = itemID;
         b.itemName = itemName;
         b.itemRev = itemRev;
         b.type = type;
         b.releaseStatus = releaseStatus;
         b.syncStatus = syncStatus;
         b.part = part;
         b.tcRev = rev;
         this.Dispatcher.Invoke(new Action(delegate {
            tcToEPlanData.Add(b);
            table_Sync_To_EPLAN.ScrollIntoView(b);
         }));
      }

      private string GetSyncStatus(string syncStatus, string type, string itemID) {
         if (!"已同步".Equals(syncStatus)) {
            if (KUtil.IsEmpty(itemID)) {
               if ("Siemens".Equals(type)) {
                  return "SAP未分配ID";
               }
               else {
                  return "新增";
               }
            }
            else {
               return NOT_SYNCED;
            }
         }
         return syncStatus;
      }

      private void Remove_Button_Click(object sender, RoutedEventArgs e) {
         try {
            System.Collections.IList selectedItems = table_Sync_To_TC.SelectedItems;
            if (selectedItems == null || selectedItems.Count == 0) {
               return;
            }
            while (selectedItems.Count > 0) {
               ePlanToTCData.Remove((PartSyncDataRow)selectedItems[0]);
               table_Sync_To_TC.Items.Refresh();
            }
            for (int i = 0; i < ePlanToTCData.Count; i++) {
               ePlanToTCData[i].index = (i + 1);
            }
            table_Sync_To_TC.Items.Refresh();
         }
         catch(System.Exception ex) {
            KUtil.LogErr(ex);
            MessageBox.Show(this, ex.Message);
         }
      }

      private void Add_All_Button_Click(object sender, RoutedEventArgs e) {
         this.bgWorker_AddAll.Start(null);
      }

      private void Query_Button_Click(object sender, RoutedEventArgs e) {
         this.bgWorker_Query.Start(null);
      }

      private void EPlan_to_TC_Button_Click(object sender, RoutedEventArgs e) {
         this.bgWorker_EPlan_to_TC.Start(null);
      }

      private void Close_Button_Click(object sender, RoutedEventArgs e) {
         Close();
      }

      private void Revise_Button_Click(object sender, RoutedEventArgs e) {
         System.Collections.IList selectedItems = table_Sync_To_TC.SelectedItems;
         if (selectedItems == null || selectedItems.Count == 0) {
            return;
         }
         List<PartSyncDataRow> reviseList = new List<PartSyncDataRow>();
         for(int i = 0; i < selectedItems.Count; i++) {
            PartSyncDataRow bean = selectedItems[i] as PartSyncDataRow;
            if (bean.tcRev!=null) {
               reviseList.Add(bean);
            }
         }
         if (reviseList.Count == 0) {
            MessageBox.Show(this, "没有可升版的数据");
            return;
         }
         bgWorker_Revise.Start(reviseList);
      }

      private void TC_to_EPLAN_Button_Click(object sender, RoutedEventArgs e) {
         this.bgWorker_TC_to_EPlan.Start(null);
      }

      private void TC_Query_Button_Click(object sender, RoutedEventArgs e) {
         tcToEPlanData.Clear();
         bgWorker_Query_TC.Start(null);
      }

      private void Tree_Parts_MouseDoubleClick(object sender, MouseButtonEventArgs e) {
         Add_Button_Click(sender, e);
      }

      private void Upload_PartsDB(object sender, RoutedEventArgs e) {
         bgWorker_UploadPartsDB.Start(null);
      }

      private void SyncErpCode_Button_Click(object sender, RoutedEventArgs e) {
         bgWorker_SyncErpCode.Start(null);
      }
   }
}