/*
 * Copyright 2019 faddenSoft
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Runtime.CompilerServices;
using System.Windows;
using System.Windows.Controls;

using Asm65;
using CommonUtil;

namespace SourceGenWPF.WpfGui {
    /// <summary>
    /// Split-address table generator.
    /// </summary>
    public partial class FormatSplitAddress : Window, INotifyPropertyChanged {
        /// Format descriptors to apply.
        /// </summary>
        public SortedList<int, FormatDescriptor> NewFormatDescriptors { get; private set; }

        /// <summary>
        /// User labels to apply.
        /// </summary>
        public Dictionary<int, Symbol> NewUserLabels { get; private set; }

        /// <summary>
        /// All target offsets found.  The list may contain redundant entries.
        /// </summary>
        public List<int> AllTargetOffsets { get; private set; }

        public bool WantCodeHints = true;   // TODO
#if false
        {
            get {
                return addCodeHintCheckBox.Checked;
            }
        }

        /// <summary>
        /// Set to true when valid output is available.
        /// </summary>
        private bool mOutputReady;
#endif

        /// <summary>
        /// Set to true when input is valid.  Controls whether the OK button is enabled.
        /// </summary>
        public bool IsValid {
            get { return mIsValid; }
            set {
                mIsValid = value;
                OnPropertyChanged();
            }
        }
        private bool mIsValid;

        /// <summary>
        /// Selected offsets.  An otherwise contiguous range of offsets can be broken up
        /// by user-specified labels and address discontinuities, so this needs to be
        /// processed by range.
        /// </summary>
        private TypedRangeSet mSelection;

        /// <summary>
        /// Project reference.
        /// </summary>
        private DisasmProject mProject;

        /// <summary>
        /// Formatter to use when displaying addresses and hex values.
        /// </summary>
        private Formatter mFormatter;

        // INotifyPropertyChanged implementation
        public event PropertyChangedEventHandler PropertyChanged;
        private void OnPropertyChanged([CallerMemberName] string propertyName = "") {
            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
        }


        public FormatSplitAddress(Window owner, DisasmProject project, TypedRangeSet selection,
                Formatter formatter) {
            InitializeComponent();
            Owner = owner;
            DataContext = this;

            mProject = project;
            mFormatter = formatter;
            mSelection = selection;
            IsValid = false;
        }

        private void Window_Loaded(object sender, RoutedEventArgs e) {
            // TDOO
        }

        private void OkButton_Click(object sender, RoutedEventArgs e) {
            DialogResult = true;
        }

#if false
        private void FormatSplitAddress_Load(object sender, EventArgs e) {
            mInitializing = true;

            string fmt = selectionInfoLabel.Text;
            selectionInfoLabel.Text = string.Format(fmt, mSelection.Count, mSelection.RangeCount);

            width16Radio.Checked = true;
            lowFirstPartRadio.Checked = true;
            highSecondPartRadio.Checked = true;
            bankNthPartRadio.Checked = true;

            incompatibleSelectionLabel.Visible = invalidConstantLabel.Visible = false;

            if (mProject.CpuDef.HasAddr16) {
                // Disable the 24-bit option.  Having 16-bit selected will disable the rest.
                width24Radio.Enabled = false;
            }

            outputPreviewListView.SetDoubleBuffered(true);

            mInitializing = false;
            UpdateControls();
        }

        private void UpdateControls() {
            if (mInitializing) {
                return;
            }
            mInitializing = true;   // no re-entry

            lowThirdPartRadio.Enabled = width24Radio.Checked;
            highThirdPartRadio.Enabled = width24Radio.Checked;
            bankByteGroupBox.Enabled = width24Radio.Checked;

            lowSecondPartRadio.Enabled = true;

            // If the user selects "constant" for high byte or bank byte, then there is no
            // 3rd part available for low/high, so we need to turn those back off.
            if (width24Radio.Checked) {
                bool haveThree = !(highConstantRadio.Checked || bankConstantRadio.Checked);
                lowThirdPartRadio.Enabled = haveThree;
                highThirdPartRadio.Enabled = haveThree;

                // If "constant" is selected for high byte *and* bank byte, then there's no
                // 2nd part available for low.
                if (highConstantRadio.Checked && bankConstantRadio.Checked) {
                    lowSecondPartRadio.Enabled = false;
                }
            } else {
                // For 16-bit address, if high byte is constant, then there's no second
                // part for the low byte.
                if (highConstantRadio.Checked) {
                    lowSecondPartRadio.Enabled = false;
                }
            }

            // Was a now-invalidated radio button selected before?
            if (!lowThirdPartRadio.Enabled && lowThirdPartRadio.Checked) {
                // low now invalid, switch to whatever high isn't using
                if (highFirstPartRadio.Checked) {
                    lowSecondPartRadio.Checked = true;
                } else {
                    lowFirstPartRadio.Checked = true;
                }
            }
            if (!highThirdPartRadio.Enabled && highThirdPartRadio.Checked) {
                // high now invalid, switch to whatever low isn't using
                if (lowFirstPartRadio.Checked) {
                    highSecondPartRadio.Checked = true;
                } else {
                    highFirstPartRadio.Checked = true;
                }
            }
            if (!lowSecondPartRadio.Enabled && lowSecondPartRadio.Checked) {
                // Should only happen when high part is constant.
                Debug.Assert(highFirstPartRadio.Checked == false);
                lowFirstPartRadio.Checked = true;
            }

            mInitializing = false;
            UpdatePreview();

            okButton.Enabled = mOutputReady;
        }

        private void widthRadio_CheckedChanged(object sender, EventArgs e) {
            UpdateControls();
        }

        private void pushRtsCheckBox_CheckedChanged(object sender, EventArgs e) {
            UpdateControls();
        }

        private void lowByte_CheckedChanged(object sender, EventArgs e) {
            // If we conflict with the high byte, change the high byte.
            if (lowFirstPartRadio.Checked && highFirstPartRadio.Checked) {
                highSecondPartRadio.Checked = true;
            } else if (lowSecondPartRadio.Checked && highSecondPartRadio.Checked) {
                highFirstPartRadio.Checked = true;
            } else if (lowThirdPartRadio.Checked && highThirdPartRadio.Checked) {
                highFirstPartRadio.Checked = true;
            }
            UpdateControls();
        }

        private void highByte_CheckedChanged(object sender, EventArgs e) {
            // If we conflict with the low byte, change the low byte.
            if (lowFirstPartRadio.Checked && highFirstPartRadio.Checked) {
                lowSecondPartRadio.Checked = true;
            } else if (lowSecondPartRadio.Checked && highSecondPartRadio.Checked) {
                lowFirstPartRadio.Checked = true;
            } else if (lowThirdPartRadio.Checked && highThirdPartRadio.Checked) {
                lowFirstPartRadio.Checked = true;
            }
            UpdateControls();
        }

        private void bankByte_CheckedChanged(object sender, EventArgs e) {
            UpdateControls();
        }

        private void highConstantTextBox_TextChanged(object sender, EventArgs e) {
            highConstantRadio.Checked = true;
            UpdateControls();
        }

        private void bankConstantTextBox_TextChanged(object sender, EventArgs e) {
            bankConstantRadio.Checked = true;
            UpdateControls();
        }

        private void UpdatePreview() {
            mOutputReady = false;

            int minDiv;

            if (width16Radio.Checked) {
                if (highConstantRadio.Checked) {
                    minDiv = 1;
                } else {
                    minDiv = 2;
                }
            } else {
                if (highConstantRadio.Checked) {
                    if (bankConstantRadio.Checked) {
                        minDiv = 1;
                    } else {
                        minDiv = 2;
                    }
                } else {
                    if (bankConstantRadio.Checked) {
                        minDiv = 2;
                    } else {
                        minDiv = 3;
                    }
                }
            }

            incompatibleSelectionLabel.Visible = invalidConstantLabel.Visible = false;

            try {
                // Start by clearing the previous contents of the list.  If something goes
                // wrong, we want to show the error messages on an empty list.
                outputPreviewListView.BeginUpdate();
                outputPreviewListView.Items.Clear();

                if ((mSelection.Count % minDiv) != 0) {
                    incompatibleSelectionLabel.Visible = true;
                    return;
                }

                int highConstant = -1;
                if (highConstantRadio.Checked) {
                    if (!Number.TryParseInt(highConstantTextBox.Text, out highConstant,
                            out int unused) || (highConstant != (byte) highConstant)) {
                        invalidConstantLabel.Visible = true;
                        return;
                    }
                }

                int bankConstant = -1;
                if (bankConstantRadio.Enabled && bankConstantRadio.Checked) {
                    if (!Number.TryParseInt(bankConstantTextBox.Text, out bankConstant,
                            out int unused) || (bankConstant != (byte) bankConstant)) {
                        invalidConstantLabel.Visible = true;
                        return;
                    }
                }

                // Looks valid, generate format list.
                GenerateFormats(minDiv, highConstant, bankConstant);
            } finally {
                outputPreviewListView.EndUpdate();
            }
        }

        private void GenerateFormats(int div, int highConst, int bankConst) {
            SortedList<int, FormatDescriptor> newDfds = new SortedList<int, FormatDescriptor>();
            Dictionary<int, Symbol> newLabels = new Dictionary<int, Symbol>();
            List<int> targetOffsets = new List<int>();

            // Identify the offset where each set of data starts.
            int span = mSelection.Count / div;
            int lowOff, highOff, bankOff;

            if (lowFirstPartRadio.Checked) {
                lowOff = 0;
            } else if (lowSecondPartRadio.Checked) {
                lowOff = span;
            } else if (lowThirdPartRadio.Checked) {
                lowOff = span * 2;
            } else {
                Debug.Assert(false);
                lowOff = -1;
            }
            if (highFirstPartRadio.Checked) {
                highOff = 0;
            } else if (highSecondPartRadio.Checked) {
                highOff = span;
            } else if (highThirdPartRadio.Checked) {
                highOff = span * 2;
            } else {
                highOff = -1;   // use constant
            }
            if (width24Radio.Checked) {
                if (bankNthPartRadio.Checked) {
                    // Use whichever part isn't being used by the other two.
                    if (lowOff != 0 && highOff != 0) {
                        bankOff = 0;
                    } else if (lowOff != span && highOff != span) {
                        bankOff = span;
                    } else {
                        Debug.Assert(lowOff != span * 2 && highOff != span * 2);
                        bankOff = span * 2;
                    }
                } else {
                    bankOff = -1;   // use constant
                }
            } else {
                bankOff = -1;       // use constant
                bankConst = 0;      // always bank 0
            }

            Debug.WriteLine("Extract from low=" + lowOff + " high=" + highOff +
                " bank=" + bankOff);

            // The TypedRangeSet doesn't have an index operation, so copy the values into
            // an array.
            int[] offsets = new int[mSelection.Count];
            int index = 0;
            foreach (TypedRangeSet.Tuple tup in mSelection) {
                offsets[index++] = tup.Value;
            }

            int adj = 0;
            if (pushRtsCheckBox.Checked) {
                adj = 1;
            }

            // Walk through the file data, generating addresses as we go.
            byte[] fileData = mProject.FileData;
            for (int i = 0; i < span; i++) {
                byte low, high, bank;

                low = fileData[offsets[lowOff + i]];
                if (highOff >= 0) {
                    high = fileData[offsets[highOff + i]];
                } else {
                    high = (byte) highConst;
                }
                if (bankOff >= 0) {
                    bank = fileData[offsets[bankOff + i]];
                } else {
                    bank = (byte) bankConst;
                }

                int addr = ((bank << 16) | (high << 8) | low) + adj;

                int targetOffset = mProject.AddrMap.AddressToOffset(offsets[0], addr);
                if (targetOffset < 0) {
                    // Address not within file bounds.
                    // TODO(maybe): look for matching platform/project symbols
                    AddPreviewItem(addr, -1, Properties.Resources.INVALID_ADDRESS);
                } else {
                    // Note the same target offset may appear more than once.
                    targetOffsets.Add(targetOffset);

                    // If there's a user-defined label there already, use it.  Otherwise, we'll
                    // need to generate one.
                    string targetLabel;
                    if (mProject.UserLabels.TryGetValue(targetOffset, out Symbol sym)) {
                        targetLabel = sym.Label;
                        AddPreviewItem(addr, targetOffset, targetLabel);
                    } else {
                        // Generate a symbol that's unique vs. the symbol table.  We don't need
                        // it to be unique vs. the labels we're generating here, because we
                        // won't generate identical labels for different addresses, and we do
                        // want to generate a single label if more than one table entry refers
                        // to the same target.
                        Symbol tmpSym = AutoLabel.GenerateUniqueForAddress(addr,
                            mProject.SymbolTable, "T");
                        // tmpSym was returned as an auto-label, make it a user label instead
                        tmpSym = new Symbol(tmpSym.Label, tmpSym.Value, Symbol.Source.User,
                            Symbol.Type.LocalOrGlobalAddr);
                        newLabels[targetOffset] = tmpSym;       // overwrites previous
                        targetLabel = tmpSym.Label;
                        AddPreviewItem(addr, targetOffset, "(+) " + targetLabel);
                    }

                    // Now we need to create format descriptors for the addresses where we
                    // extracted the low, high, and bank values.
                    newDfds.Add(offsets[lowOff + i], FormatDescriptor.Create(1,
                        new WeakSymbolRef(targetLabel, WeakSymbolRef.Part.Low), false));
                    if (highOff >= 0) {
                        newDfds.Add(offsets[highOff + i], FormatDescriptor.Create(1,
                            new WeakSymbolRef(targetLabel, WeakSymbolRef.Part.High), false));
                    }
                    if (bankOff >= 0) {
                        newDfds.Add(offsets[bankOff + i], FormatDescriptor.Create(1,
                            new WeakSymbolRef(targetLabel, WeakSymbolRef.Part.Bank), false));
                    }
                }
            }

            NewFormatDescriptors = newDfds;
            NewUserLabels = newLabels;
            AllTargetOffsets = targetOffsets;

            // Don't show ready if all addresses are invalid.
            mOutputReady = (AllTargetOffsets.Count > 0);
        }

        private void AddPreviewItem(int addr, int offset, string label) {
            ListViewItem lvi = new ListViewItem(mFormatter.FormatAddress(addr,
                !mProject.CpuDef.HasAddr16));
            if (offset >= 0) {
                lvi.SubItems.Add(new ListViewItem.ListViewSubItem(lvi,
                    mFormatter.FormatOffset24(offset)));
            } else {
                lvi.SubItems.Add(new ListViewItem.ListViewSubItem(lvi, "---"));
            }
            lvi.SubItems.Add(new ListViewItem.ListViewSubItem(lvi, label));
            outputPreviewListView.Items.Add(lvi);
        }
#endif
    }
}