module TraceConverter =
    type TraceBlock () =
        member val Position = "" with get, set
        member val Command = "" with get, set
        member val Argument = "" with get, set
        member val Registers = new Dictionary<string, string> () with get, set
        member val Flags = new Dictionary<string, string> () with get, set
        member val Stack = "" with get, set
        member this.TryGetRegister (data : string) =
            match this.Registers.TryGetValue data with
                | true, v ->
                    try Int32.Parse(v, Globalization.NumberStyles.AllowHexSpecifier)
                    with | exn -> 0
                | false, _ ->
                    try Int32.Parse(data, Globalization.NumberStyles.AllowHexSpecifier)
                    with | exn -> 0
        member this.TryGetAddress : string =
            let parsed = Regex.Match(this.Argument, @"\[.+\]")
            if not parsed.Success then
                ""
            else
                let mutable sum = 0
                let mutable ans = ""
                let clean = parsed.Value.Replace("[", "").Replace("]", "")
                let unsignedMember = Regex.Match(clean, @"^\w+")
                let captures = Regex.Matches(clean, @"[+,-]\w+")
                if unsignedMember.Success then
                    let pnum = this.TryGetRegister unsignedMember.Value
                    sum <- sum + pnum
                for cap in captures do
                    let mutable IsNegative = 1
                    if cap.Value.StartsWith('-') then
                        IsNegative <- -IsNegative
                    let pnum = this.TryGetRegister(cap.Value.TrimStart([|'+'; '-'|]))
                    sum <- sum + pnum*IsNegative
                ans <- String.Format("{0:X}", sum)
                while ans.Length < 4 do ans <- "0"+ans
                ans

    type TraceBlockS () =
        member val Id = -1 with get, set
        member val Position = "" with get, set
        member val MachineCode = "" with get, set
        member val Command = "" with get, set
        member val Argument = "" with get, set

module ConverterHelper =
    let ConvertToTrace (raw : List<string>) : byte array =
        let transformed = raw.Skip(3).TakeWhile(fun line -> not (line.Contains "*** End of TRACE buffer ***"))
        let traceBlocks = new List<IEnumerable<string>>()
        for i in [0..((transformed.Count()/4)-1)] do
            traceBlocks.Add(transformed.Skip(4*i).Take(4))
        use ep = new ExcelPackage() in (
            let ws = ep.Workbook.Worksheets.Add("TraceTable")
            let mutable tCounter = 2
            TableHelper.WriteTraceHeaders ws;
            for b in traceBlocks do
                tCounter <- tCounter + 1
                let tb = TableHelper.ReadTraceBlock(b)
                TableHelper.WriteTraceLine(ws, tb, tCounter)
            let prevVal =
                try Int32.Parse(ws.Cells.["A"+ (string) tCounter].Value.ToString(), Globalization.NumberStyles.AllowHexSpecifier) with
                | _ -> 0
            let mutable lastPos = String.Format("{0:X}", prevVal+1)
            while lastPos.Length < 4 do lastPos <- "0" + lastPos
            ws.Cells.["G" + (string) tCounter].Value <- lastPos
            ep.GetAsByteArray()
        )
    let ConvertToCode (raw : List<string>) : byte array =
        let transofrmed = raw.Skip(3).TakeWhile(fun line -> not (line.Contains "*** End of TRACE buffer ***"))
        use ep = new ExcelPackage() in (
            let ws = ep.Workbook.Worksheets.Add("CodeTable")
            let ul = new SortedList<int, TraceConverter.TraceBlockS>()
            TableHelper.WriteCodeHeaders ws
            for line in transofrmed do
                let tbs = TableHelper.ReadCodeLine(line)
                ul.[tbs.Id] <- tbs
            let mutable tc = 1
            for kvp in ul do
                tc <- tc + 1
                TableHelper.WriteCodeLine ws kvp.Value tc
            ep.GetAsByteArray()
        )