/******************************************************************************
 * The MIT License (MIT)
 * 
 * Copyright (c) 2015-2016 Baldur Karlsson
 * Copyright (c) 2014 Crytek
 * 
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 * 
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 * 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 ******************************************************************************/


using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using WeifenLuo.WinFormsUI.Docking;
using renderdocui.Code;
using renderdoc;

namespace renderdocui.Windows
{
    public partial class PixelHistoryView : DockContent, ILogViewerForm
    {
        struct EventTag
        {
            public EventTag(uint eid, uint prim)
            {
                EID = eid;
                Primitive = prim;
            }

            public uint EID;
            public uint Primitive;
        };

        Core m_Core;
        FetchTexture texture;
        Point pixel;
        uint sample;
        PixelModification[] modifications;
        bool[] visibleChannels;
        float rangeMin, rangeMax;
        int numChannels, channelIdx;

        public PixelHistoryView(Core core, FetchTexture tex, Point pt, UInt32 sampleIdx,
                                float rangemin, float rangemax, bool[] channels)
        {
            InitializeComponent();

            Icon = global::renderdocui.Properties.Resources.icon;

            m_Core = core;

            events.Font =
                core.Config.PreferredFont;

            texture = tex;
            pixel = pt;
            rangeMin = rangemin;
            rangeMax = rangemax;
            visibleChannels = channels;
            sample = sampleIdx;

            Text = String.Format("Pixel History on {0} for ({1}, {2})", tex.name, pt.X, pt.Y);
            if(tex.msSamp > 1)
                Text += String.Format(" @ Sample {0}", sample);

            string channelStr = "";
            numChannels = 0;
            channelIdx = 0;

            if (channels[0])
            {
                channelStr += "R";
                numChannels++;
                channelIdx = 0;
            }
            if (channels[1])
            {
                channelStr += "G";
                numChannels++;
                channelIdx = 1;
            }
            if (channels[2])
            {
                channelStr += "B";
                numChannels++;
                channelIdx = 2;
            }

            channelStr += " channel";
            if (numChannels > 1)
                channelStr += "s";

            // if alpha channel is enabled it only does anything if the
            // other channels are all disabled. There is no RGBA preview
            if (numChannels == 0 && channels[3])
            {
                channelStr = "Alpha";
                numChannels = 1;
                channelIdx = 3;
            }

            historyContext.Text = String.Format("Preview colours displayed in visible range {0} - {1} with {2} visible.",
                                                Formatter.Format(rangemin), Formatter.Format(rangemax), channelStr) + Environment.NewLine;
            historyContext.Text += Environment.NewLine;
            historyContext.Text += "Double click to jump to an event." + Environment.NewLine;
            historyContext.Text += "Right click to debug an event, or hide failed events.";

            eventsHidden.Text = "";

            modifications = null;

            events.BeginUpdate();

            events.Nodes.Clear();

            events.Nodes.Add(new object[] { "Loading...", "", "", "", "" });

            events.EndUpdate();
        }

        public void SetHistory(PixelModification[] history)
        {
            modifications = history;

            UpdateEventList();

            PixelHistoryView_Enter(null, null);
        }

        private string[] colourLetterPrefix = new string[] { "R: ", "G: ", "B: ", "A: " };

        private string ModificationValueString(ModificationValue val, ResourceFormat fmt, bool depth)
        {
            string s = "";

            bool uintTex = (fmt.compType == FormatComponentType.UInt);
            bool sintTex = (fmt.compType == FormatComponentType.SInt);
            int numComps = (int)(fmt.compCount);

            if (!depth)
            {
                if (uintTex)
                {
                    for (int i = 0; i < numComps; i++)
                        s += colourLetterPrefix[i] + val.col.value.u[i].ToString() + "\n";
                }
                else if (sintTex)
                {
                    for (int i = 0; i < numComps; i++)
                        s += colourLetterPrefix[i] + val.col.value.i[i].ToString() + "\n";
                }
                else
                {
                    for (int i = 0; i < numComps; i++)
                        s += colourLetterPrefix[i] + Formatter.Format(val.col.value.f[i]) + "\n";
                }
            }

            if (val.depth >= 0.0f)
                s += "\nD: " + Formatter.Format(val.depth);
            else if (val.depth < -1.5f)
                s += "\nD: ?";
            else
                s += "\nD: -";

            if (val.stencil >= 0)
                s += String.Format("\nS: 0x{0:X2}", val.stencil);
            else if (val.stencil == -2)
                s += "\nS: ?";
            else
                s += "\nS: -";

            return s;
        }

        private Color ModificationValueColor(ModificationValue val, bool depth)
        {
            float rangesize = (rangeMax - rangeMin);

            float r = val.col.value.f[0];
            float g = val.col.value.f[1];
            float b = val.col.value.f[2];

            if (numChannels == 1)
            {
                r = g = b = val.col.value.f[channelIdx];
            }
            else
            {
                if (!visibleChannels[0]) r = 0.0f;
                if (!visibleChannels[1]) g = 0.0f;
                if (!visibleChannels[2]) b = 0.0f;
            }

            r = Helpers.Clamp((r - rangeMin) / rangesize, 0.0f, 1.0f);
            g = Helpers.Clamp((g - rangeMin) / rangesize, 0.0f, 1.0f);
            b = Helpers.Clamp((b - rangeMin) / rangesize, 0.0f, 1.0f);

            if (depth)
                r = g = b = Helpers.Clamp((val.depth - rangeMin) / rangesize, 0.0f, 1.0f);

            {
                r = (float)Math.Pow(r, 1.0f / 2.2f);
                g = (float)Math.Pow(g, 1.0f / 2.2f);
                b = (float)Math.Pow(b, 1.0f / 2.2f);
            }

            return Color.FromArgb((int)(255.0f * r), (int)(255.0f * g), (int)(255.0f * b));
        }

        private string FailureString(PixelModification mod)
        {
            string s = "";

            if (mod.sampleMasked)
                s += "\nMasked by SampleMask";
            if (mod.backfaceCulled)
                s += "\nBackface culled";
            if (mod.depthClipped)
                s += "\nDepth Clipped";
            if (mod.scissorClipped)
                s += "\nScissor Clipped";
            if (mod.shaderDiscarded)
                s += "\nShader executed a discard";
            if (mod.depthTestFailed)
                s += "\nDepth test failed";
            if (mod.stencilTestFailed)
                s += "\nStencil test failed";

            return s;
        }

        private TreelistView.Node MakeFragmentNode(PixelModification mod)
        {
            bool uintTex = (texture.format.compType == FormatComponentType.UInt);
            bool sintTex = (texture.format.compType == FormatComponentType.SInt);
            bool floatTex = (!uintTex && !sintTex);

            bool depth = false;

            if (texture.format.compType == FormatComponentType.Depth ||
                (texture.format.special && texture.format.specialFormat == SpecialFormat.D16S8) ||
                (texture.format.special && texture.format.specialFormat == SpecialFormat.D24S8) ||
                (texture.format.special && texture.format.specialFormat == SpecialFormat.D32S8) ||
                (texture.format.special && texture.format.specialFormat == SpecialFormat.S8))
                depth = true;

            TreelistView.Node node = null;

            if (mod.uavWrite)
            {
                string name = "Potential UAV/Copy write";

                string preModVal = "Tex Before\n\n" + ModificationValueString(mod.preMod, texture.format, depth);
                string postModVal = "Tex After\n\n" + ModificationValueString(mod.postMod, texture.format, depth);

                if (mod.preMod.col.value.u[0] == mod.postMod.col.value.u[0] &&
                    mod.preMod.col.value.u[1] == mod.postMod.col.value.u[1] &&
                    mod.preMod.col.value.u[2] == mod.postMod.col.value.u[2] &&
                    mod.preMod.col.value.u[3] == mod.postMod.col.value.u[3])
                {
                    name += "\nNo change in tex value";
                }

                node = new TreelistView.Node(new object[] { name, preModVal, "", postModVal, "" });
            }
            else
            {
                string name = String.Format("Primitive {0}\n", mod.primitiveID);

                if (mod.shaderDiscarded)
                    name += FailureString(mod);

                ResourceFormat fmt = new ResourceFormat(floatTex ? FormatComponentType.Float : texture.format.compType, 4, 4);

                string shadOutVal;
                string postModVal = "Tex After\n\n" + ModificationValueString(mod.postMod, texture.format, depth);

                if (mod.unboundPS)
                    shadOutVal = "No Pixel\nShader\nBound";
                else
                    shadOutVal = "Shader Out\n\n" + ModificationValueString(mod.shaderOut, fmt, depth);

                if (!mod.EventPassed() && hideFailedEventsToolStripMenuItem.Checked)
                    return null;

                node = new TreelistView.Node(new object[] { name, shadOutVal, "", postModVal, "" });

                if (mod.shaderDiscarded)
                    node.DefaultBackColor = Color.FromArgb(255, 235, 235);
            }

            node.Tag = new EventTag(mod.eventID, mod.uavWrite ? uint.MaxValue : mod.primitiveID);

            if (floatTex || depth)
            {
                node.IndexedBackColor[2] = ModificationValueColor(mod.shaderOut, depth);
                node.IndexedBackColor[4] = ModificationValueColor(mod.postMod, depth);
            }

            return node;
        }

        private TreelistView.Node MakeEventNode(List<TreelistView.Node> nodes, List<PixelModification> mods)
        {
            bool uintTex = (texture.format.compType == FormatComponentType.UInt);
            bool sintTex = (texture.format.compType == FormatComponentType.SInt);
            bool floatTex = (!uintTex && !sintTex);

            bool depth = false;

            if (texture.format.compType == FormatComponentType.Depth ||
                (texture.format.special && texture.format.specialFormat == SpecialFormat.D24S8) ||
                (texture.format.special && texture.format.specialFormat == SpecialFormat.D32S8) ||
                (texture.format.special && texture.format.specialFormat == SpecialFormat.S8))
                depth = true;

            var drawcall = m_Core.GetDrawcall(mods[0].eventID);
            if (drawcall == null) return null;

            string name = "";
            var drawstack = new List<FetchDrawcall>();
            var parent = drawcall.parent;
            while (parent != null)
            {
                drawstack.Add(parent);
                parent = parent.parent;
            }

            drawstack.Reverse();

            if (drawstack.Count > 0)
            {
                name += "> " + drawstack[0].name;

                if (drawstack.Count > 3)
                    name += " ...";

                name += "\n";

                if (drawstack.Count > 2)
                    name += "> " + drawstack[drawstack.Count - 2].name + "\n";
                if (drawstack.Count > 1)
                    name += "> " + drawstack[drawstack.Count - 1].name + "\n";

                name += "\n";
            }

            bool passed = true;
            bool uavnowrite = false;

            if (mods[0].uavWrite)
            {
                name += String.Format("EID {0}\n{1}\nBound as UAV or copy - potential modification", mods[0].eventID, drawcall.name);

                if (mods[0].preMod.col.value.u[0] == mods[0].postMod.col.value.u[0] &&
                    mods[0].preMod.col.value.u[1] == mods[0].postMod.col.value.u[1] &&
                    mods[0].preMod.col.value.u[2] == mods[0].postMod.col.value.u[2] &&
                    mods[0].preMod.col.value.u[3] == mods[0].postMod.col.value.u[3])
                {
                    name += "\nNo change in tex value";
                    uavnowrite = true;
                }
            }
            else
            {
                passed = mods.Any(m => m.EventPassed());

                string failure = passed ? "" : FailureString(mods[0]);

                name += String.Format("EID {0}\n{1}{2}\n{3} Fragments touching pixel\n", mods[0].eventID, drawcall.name, failure, nodes.Count);
            }

            string preModVal = "Tex Before\n\n" + ModificationValueString(mods.First().preMod, texture.format, depth);
            string postModVal = "Tex After\n\n" + ModificationValueString(mods.Last().postMod, texture.format, depth);

            var node = new TreelistView.Node(new object[] { name, preModVal, "", postModVal, "" });

            node.DefaultBackColor = passed ? Color.FromArgb(235, 255, 235) : Color.FromArgb(255, 235, 235);
            node.Tag = new EventTag(mods[0].eventID, uint.MaxValue);

            if (uavnowrite)
                node.DefaultBackColor = Color.FromArgb(235, 235, 235);

            if (floatTex || depth)
            {
                node.IndexedBackColor[2] = ModificationValueColor(mods.First().preMod, depth);
                node.IndexedBackColor[4] = ModificationValueColor(mods.Last().postMod, depth);
            }

            if ((drawcall.flags & DrawcallFlags.Clear) == 0)
            {
                foreach (var child in nodes)
                    node.Nodes.Add(child);
            }

            return node;
        }

        private void UpdateEventList()
        {
            events.BeginUpdate();

            events.Nodes.Clear();

            if (modifications == null)
            {
                events.EndUpdate();
                return;
            }

            var frags = new List<TreelistView.Node>();
            var mods = new List<PixelModification>();

            for(int i=0; i < modifications.Length; i++)
            {
                var node = MakeFragmentNode(modifications[i]);
                if (node == null) continue;

                frags.Add(node);
                mods.Add(modifications[i]);

                if (i + 1 >= modifications.Length || modifications[i + 1].eventID != modifications[i].eventID)
                {
                    if(frags.Count > 0)
                        events.Nodes.Add(MakeEventNode(frags, mods));

                    frags.Clear();
                    mods.Clear();
                }
            }

            events.EndUpdate();
        }

        public void OnLogfileClosed()
        {
            Close();
        }

        public void OnLogfileLoaded()
        {
        }

        public void OnEventSelected(UInt32 eventID)
        {
        }

        private void events_NodeDoubleClicked(TreelistView.Node node)
        {
            if (node.Tag is EventTag)
            {
                m_Core.SetEventID(this, ((EventTag)node.Tag).EID);
            }
        }

        private void events_MouseClick(object sender, MouseEventArgs e)
        {
            if (e.Button == MouseButtons.Right)
            {
                debugToolStripMenuItem.Enabled = false;
                debugToolStripMenuItem.Text = "Debug Pixel";

                jumpToPrimitiveMenuItem.Visible = false;

                if (events.SelectedNode != null && events.SelectedNode.Tag != null && events.SelectedNode.Tag is EventTag)
                {
                    EventTag tag = (EventTag)events.SelectedNode.Tag;
                    debugToolStripMenuItem.Enabled = true;
                    if (tag.Primitive == uint.MaxValue)
                    {
                        debugToolStripMenuItem.Text = String.Format("Debug Pixel ({0}, {1}) at Event {3}",
                                                                        pixel.X, pixel.Y, tag.Primitive, tag.EID);
                    }
                    else
                    {
                        debugToolStripMenuItem.Text = String.Format("Debug Pixel ({0}, {1}) primitive {2} at Event {3}",
                                                                        pixel.X, pixel.Y, tag.Primitive, tag.EID);

                        jumpToPrimitiveMenuItem.Text = String.Format("Show primitive {0} at Event {1}", tag.Primitive, tag.EID);
                        jumpToPrimitiveMenuItem.Visible = true;
                    }
                }

                rightclickMenu.Show(events.PointToScreen(e.Location));
            }
        }

        private void jumpToPrimitiveMenuItem_Click(object sender, EventArgs e)
        {
            if (events.SelectedNode == null) return;

            var node = events.SelectedNode;

            if (node.Tag is EventTag)
            {
                EventTag tag = (EventTag)node.Tag;

                m_Core.SetEventID(this, tag.EID);

                UInt32 vertIdx = m_Core.CurDrawcall.topology.GetVertexOffset(tag.Primitive);

                var viewer = m_Core.GetMeshViewer();
                viewer.Show(DockPanel);

                if (!viewer.IsDisposed && vertIdx != ~0U)
                    viewer.RowOffset = (int)vertIdx;
            }
        }

        private void debugToolStripMenuItem_Click(object sender, EventArgs e)
        {
            if (events.SelectedNode == null) return;

            var node = events.SelectedNode;

            if (node.Tag is EventTag)
            {
                EventTag tag = (EventTag)node.Tag;

                m_Core.SetEventID(this, tag.EID);

                ShaderDebugTrace trace = null;

                ShaderReflection shaderDetails = m_Core.CurPipelineState.GetShaderReflection(ShaderStageType.Pixel);

                m_Core.Renderer.Invoke((ReplayRenderer r) =>
                {
                    trace = r.DebugPixel((UInt32)pixel.X, (UInt32)pixel.Y, sample, tag.Primitive);
                });

                if (trace == null || trace.states.Length == 0)
                {
                    MessageBox.Show("Error debugging pixel.", "Debug Error",
                                    MessageBoxButtons.OK, MessageBoxIcon.Error);
                    return;
                }

                this.BeginInvoke(new Action(() =>
                {
                    string debugContext = String.Format("Pixel {0},{1}", pixel.X, pixel.Y);

                    ShaderViewer s = new ShaderViewer(m_Core, shaderDetails, ShaderStageType.Pixel, trace, debugContext);

                    s.Show(this.DockPanel);
                }));
            }
        }

        private void hideFailedEventsToolStripMenuItem_CheckedChanged(object sender, EventArgs e)
        {
            if (hideFailedEventsToolStripMenuItem.Checked)
                eventsHidden.Text = "Failed events are currently hidden";
            else
                eventsHidden.Text = "";

            UpdateEventList();
        }

        private void PixelHistoryView_Enter(object sender, EventArgs e)
        {
            var timeline = m_Core.GetTimelineBar();

            if (timeline != null)
                timeline.HighlightHistory(texture, pixel, modifications);
        }

        private void PixelHistoryView_Leave(object sender, EventArgs e)
        {
            var timeline = m_Core.GetTimelineBar();

            if (timeline != null)
                timeline.HighlightHistory(null, Point.Empty, null);
        }

        private void PixelHistoryView_FormClosed(object sender, FormClosedEventArgs e)
        {
            var timeline = m_Core.GetTimelineBar();

            if (timeline != null)
                timeline.HighlightHistory(null, Point.Empty, null);
        }
    }
}