using System;
using System.Drawing;
using System.Collections;
using System.ComponentModel;
using System.Windows.Forms;
using System.Data;
using System.Data.OleDb;
using System.Collections.Specialized;
using System.Collections.Generic;
using System.Xml;
using System.IO;
using System.Text;
using VEPROMS.CSLA.Library;

namespace DataLoader
{
	public partial class Loader
	{
		private Item AddStep(OleDbConnection cn, string StepType, string Textm, string Recid, string stpseq, string structtype, Item FromItem, DateTime dts, string userid, bool conv_caret, string pth)
		{
            Content content = null;
			Item item = null;
			
			frmMain.UpdateLabels(0, 0, 1);
			ConfigInfo ci = null;
            string stptext = null;
			if (userid == null || userid == "") userid = "Migration";
            int tok = -1;
			char[] chrarr = { '\x1', '\x2', '\x3', '\x5' };
			try
			{
				// the textm field has step text, but also may have other text stored
				// with it with a 'token' as a separator (see below).
				tok = Textm.IndexOfAny(chrarr);
				if (tok < 0)
					stptext = TextConvert.ConvertText(Textm, conv_caret);
				else
					stptext = TextConvert.ConvertText(Textm.Substring(0, tok), conv_caret);

				string seqcvt = TextConvert.ConvertSeq(stpseq);

				// Figure marker - it should NEVER get here!!!
				int tokfig = Textm.IndexOf('\xE8');
				if (tokfig > -1)
				{
					log.Error("Found a old style figure!");
					log.ErrorFormat("oldstepsequence = {0}", stpseq);
				}
				string newstptyp = null;
				bool ManualPagebreak = false;
				char cbittst = StepType.PadRight(2)[0];
				if (cbittst != ' ' && (cbittst & 0x80) > 1)
				{
					ManualPagebreak = true;
					if (ci == null) ci = new ConfigInfo(null);
					ci.AddItem("Step", "ManualPagebreak", "True");
					newstptyp = StepType.Substring(1, 1);
				}

				// Need the content record for the RO & transitions.
				//content = Content.MakeContent(null, stptext, 20000 + int.Parse(newstptyp!=null?newstptyp:StepType),null, ManualPagebreak?ci.ToString():null, dts, userid);
				content = Content.New(null, stptext, 20000 + int.Parse(newstptyp != null ? newstptyp : StepType), null, ManualPagebreak ? ci.ToString() : null, dts, userid);
				content.MyZContent.OldStepSequence = ProcNumber + "|" + stpseq;

				// Before we save it, handle RO & Transitions tokens.
				int tokrt = Textm.IndexOf('\x15');
				bool txtdirty = false;
				if (tokrt > -1)
				{
					txtdirty = true;
					stptext = MigrateRos(cn, stptext, seqcvt, content);
				}

				// 16-bit code has the following two defines.
				//		#define TransitionMarker 0xC2
				//		#define ReferenceMarker 0xCB
				//		these two characters get converted (to unicode) from ado.net
				//		use the unicode chars.
				char[] chrrotrn = { '\x252C', '\x2566' };
				tokrt = Textm.IndexOfAny(chrrotrn);
				_TransitionMigrationErrors = new List<string>();
				if (tokrt > -1)
				{
					txtdirty = true;
					stptext = MigrateTrans(cn, stptext, seqcvt, content, pth);
				}
				if (txtdirty)
				{
					content.Text = stptext;
					//content.Save();
				}
				if (!content.IsSavable) ErrorRpt.ErrorReport(content);
				List<string> migrationerrors = null;
				if (_ContentMigrationErrors.ContainsKey(content.ContentID))
					migrationerrors = _ContentMigrationErrors[content.ContentID];
				content.Save();
				// check if already created thru new during transition migration...
				if (dicTrans_ItemIds.ContainsKey(ProcNumber + "|" + seqcvt))
				{
					item = dicTrans_ItemIds[ProcNumber + "|" + seqcvt];
					item.MyPrevious = FromItem;
					item.MyContent = content;
					item.DTS = dts;
					item.UserID = userid;
					if (!item.IsSavable) ErrorRpt.ErrorReport(item);
					item.Save();
					dicTrans_ItemIds.Remove(ProcNumber + "|" + seqcvt);
					dicTrans_MigrationErrors.Remove(ProcNumber + "|" + seqcvt);
				}
				else
					item = Item.MakeItem(FromItem, content, content.DTS, content.UserID);
				if (migrationerrors != null)
				{
					foreach (string str in migrationerrors)
					{
						ItemAnnotation ia = item.ItemAnnotations.Add(MigrationErrorType);
						ia.SearchText = str;
					}
					if (!item.IsSavable) ErrorRpt.ErrorReport(item);
					item.Save();
				}
				if (_TransitionMigrationErrors.Count > 0)
				{
					foreach (string str in _TransitionMigrationErrors)
					{
						if (!dicTrans_MigrationErrors.ContainsKey(str))
							dicTrans_MigrationErrors.Add(str, new List<Item>());
						dicTrans_MigrationErrors[str].Add(item);
					}
				}
				dicTrans_ItemDone[ProcNumber + "|" + seqcvt] = item;
				dicOldStepSequence[content] = seqcvt;
			}
			catch (Exception ex)
			{
				log.Error("Save Step");
				log.ErrorFormat("oldstepsequence = {0}", stpseq);
				log.ErrorFormat("{0}\r\n\r\n{1}", ex.Message, ex.InnerException);
				log.ErrorFormat(ex.StackTrace);
				item = null;
			}

			// now add on any support pieces of text associated with the step.
			// These include:
			//      '\1'  comment
			//      '\2'  multiple change ids and/or change message
			//      '\3'  linked sequence
			//      '\3\3'override tab
			//      '\5'  continuous action summary flag

            bool recdirty = false;
			try
			{
				while (tok >= 0 && tok != Textm.Length)
				{
					int nxttok = Textm.IndexOfAny(chrarr, tok + 1);
                    
					char chr = Textm[tok];
					int typ = 0;
                    if (chr == '\x1')
                    {
                        // add the comment to annotation table.  Set type to comment.
                        if (nxttok < 0) nxttok = Textm.Length;
                        Annotation annot = Annotation.MakeAnnotation(item, CommentType, null, Textm.Substring(tok + 1, nxttok - tok - 1), null, dts, userid);
                    }
                    else if (chr == '\x2')
                        typ = STP_MULT_CHGID;
                    else if (chr == '\x3')
                    {
                        typ = STP_LNK_SEQ;
                        // check for a double \3 - override tab.
                        if (tok + 1 < Textm.Length)
                        {
                            char nxttokchr = Textm[tok + 1];
                            if (nxttokchr == '\x3')
                            {
                                typ = STP_OVR_TAB;
                                tok++;      // this was a double \3, get past 1st one.
                                nxttok = Textm.IndexOfAny(chrarr, tok + 1);
                            }
                        }
                    }
                    else if (chr == '\x5')
                    {
                        recdirty = true;
						if (ci == null) ci = new ConfigInfo(null);
                        ci.AddItem("Step", "ContActSum", "True");
                        if (nxttok < 0) nxttok = Textm.Length;
                    }

					// if not comment or ContActSum (xml) make a steptext element
					if (typ == STP_MULT_CHGID || typ == STP_LNK_SEQ || typ == STP_OVR_TAB)
					{
						if (nxttok < 0) nxttok = Textm.Length;
						// if this is a sequence number - may need to convert hi-end chars
						string strn = null;
						if (typ == STP_LNK_SEQ)
							strn = TextConvert.ConvertSeq(Textm.Substring(tok + 1, nxttok - tok - 1));
						else
							strn = Textm.Substring(tok + 1, nxttok - tok - 1);
						if (strn != null && strn != "")
						{
							recdirty = true;
							content.ContentDetails.Add(typ, strn);
						}
					}
					tok = nxttok;
				}

				// also see if a check-off needs added.
				if (Recid[0] != '0')
				{
                    recdirty = true;
					string chkindx = Recid[0].ToString();
					if (ci == null) ci = new ConfigInfo(null);
					ci.AddItem("Step", "CheckOffIndex", chkindx);
				}

				// here's where it knows if it's a linked step (or in processstep)
				if (Recid[1] != '0')
				{
					// do linked step stuff.
				}

				// if checkoffs or the continuous action summary flag, save the xml.
                if (recdirty)
                {
                    if (ci != null) content.Config = ci.ToString();
					if (!content.IsSavable) ErrorRpt.ErrorReport(content);
					content.Save();
                }
			}
			catch (Exception ex)
			{
                log.Error("Save Step part 2");
                log.ErrorFormat("oldstepsequence = {0}", stpseq);
                log.ErrorFormat("{0}\r\n\r\n{1}", ex.Message, ex.InnerException);
                log.ErrorFormat(ex.StackTrace);
			}
			return item;
		}
		private string GetParent(string s)
		{
			string retval = "S";
			if (s.Length > 1)
			{
				int l = s.Length;
				if ("!*".IndexOf(s[l - 2]) > -1)
				{
					if (l > 2) retval = s.Substring(0, l - 2);
				}
				else
				{
					retval = s.Substring(0, l - 1);
				}
			}
			return retval;
		}
		private string GetStructType(string s)
		{
			string retval = "S";
			if (s.Length > 1)
			{
				int l = s.Length;
				if ("!*".IndexOf(s[l - 2]) > -1)
				{
					if (s[l - 2] == '!') retval = "C";
					else retval = "N";
				}
				else
				{
					if (s[l - 1] == '$') retval = "R";
					if (s[l - 1] == '#') retval = "T";
				}
			}
			return retval;
		}
		private Item MigrateStep(OleDbConnection cn, DataTable dt, DataRowView drv, Item FromItem, bool conv_caret, string pth)
		{
			try
			{
				string sType = GetStructType(drv["CSequence"].ToString());
				Item item = AddStep(cn, drv["Type"].ToString()
				        , (drv["textm"] == DBNull.Value ? drv["Text"].ToString() : drv["Textm"].ToString())
				        , drv["Recid"].ToString(), drv["CStep"].ToString() + drv["CSequence"].ToString(), "S", FromItem  // was str
				        , GetDTS(drv["Date"].ToString(), drv["Time"].ToString()), drv["Initials"].ToString(), conv_caret, pth);
				//Content cont = Content.MakeContent(null,(drv["textm"] == DBNull.Value ? drv["Text"].ToString() : drv["Textm"].ToString()),drv["Type"]+20000,null,null,
				//    GetDTS(drv["Date"].ToString(), drv["Time"].ToString()), drv["Initials"].ToString());
				//Item item = Item.MakeItem(FromItem, cont, cont.DTS, cont.UserID); 
				//Structure str = AddStructure(FromType, FromID, 3, tmpid, drv["CStep"].ToString() + drv["CSequence"].ToString(),
				//            GetDTS(drv["Date"].ToString(), drv["Time"].ToString()), drv["Initials"].ToString());
				//Step stp = AddStep(cn, drv["Type"].ToString()
				//        , (drv["textm"] == DBNull.Value ? drv["Text"].ToString() : drv["Textm"].ToString())
				//        , drv["Recid"].ToString(), drv["CStep"].ToString() + drv["CSequence"].ToString(), "S", str
				//        , GetDTS(drv["Date"].ToString(), drv["Time"].ToString()), drv["Initials"].ToString());
                Dictionary<string, Item> dicStep = new Dictionary<string, Item>();
				dicStep[drv["CSequence"].ToString()] = item;
                Dictionary<string, Dictionary<string, Item>> dicStruct = new Dictionary<string, Dictionary<string, Item>>();
				Dictionary<string, Item> dicBase = new Dictionary<string, Item>();
				dicStruct[drv["CSequence"].ToString()] = dicBase;
				dicBase[""] = item;
				// Logic to add Sub-steps
				string sQry = "CStep = '" + drv["CStep"].ToString() + "' and CSequence <> 'S'";
				// sort order - for sections use currentrows.
				DataView dv = new DataView(dt, sQry, "StepNo,Level,SubStepNo", DataViewRowState.CurrentRows);
				//dataGrid1.DataSource=dv;
				//Loop through DataView and add Steps one at a time
				//Console.WriteLine("={0}",drv["Step"]);
				int FrType = 0;			// type of relationship (not type of step)
				Item FrItem = item;
				foreach (DataRowView drvs in dv)
				{
					//Console.WriteLine(">{0}",drvs["CStep"]);

					string sParent = GetParent(drvs["CSequence"].ToString());
					if (dicStep.ContainsKey(sParent))
					{
						Item itemp = dicStep[sParent];
						sType = GetStructType(drvs["CSequence"].ToString());
						Dictionary<string,Item> dicStr = dicStruct[sParent];
						// check if a step type of 'sType' exists to see if child/sibling
						//Content contc = Content.MakeContent(null,(drvs["textm"] == DBNull.Value ? drvs["Text"].ToString() : drvs["Textm"].ToString()),drvs["Type"]+20000,null,null,
						//	GetDTS(drvs["Date"].ToString(), drvs["Time"].ToString()), drvs["Initials"].ToString()));
						Item itemc = null;
						if (dicStr.ContainsKey(sType))   // next sibling
						{
							FrItem = dicStr[sType];
							FrType = 0;
						}
						else  // child of a node
						{
							FrItem = null;
							FrType = (3 + ("CNRST".IndexOf(sType)));
						}
						itemc = AddStep(cn, drvs["Type"].ToString()
							, (drvs["textm"] == DBNull.Value ? drvs["Text"].ToString() : drvs["Textm"].ToString())
							, drv["Recid"].ToString(), drvs["CStep"].ToString() + drvs["CSequence"].ToString()
							, GetStructType(drvs["sequence"].ToString()), FrItem
							, GetDTS(drvs["Date"].ToString(), drvs["Time"].ToString()), drvs["Initials"].ToString(), conv_caret, pth);
							
						if (FrType > 0 )
						{						
							itemp.MyContent.ContentParts.Add(FrType, itemc);
							if (!itemp.MyContent.IsSavable) ErrorRpt.ErrorReport(itemp.MyContent);
							itemp.MyContent.Save();
						}
						dicStr[sType] = itemc;
						dicStruct[drvs["CSequence"].ToString()] = new Dictionary<string, Item>();
						dicStep[drvs["CSequence"].ToString()] = itemc;		
					}
					else
					{
                        log.ErrorFormat("Parent {0} Could not be found for {1}", sParent, drvs["sequence"].ToString());
					}
				}
				return item;
			}
			catch (Exception ex)
			{
                log.Error("PROCESS STEP");
                log.ErrorFormat("{0}\r\n\r\n{1}", ex.Message, ex.InnerException);
                log.ErrorFormat(ex.StackTrace);
				return null;
			}
		}
	}
}