using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using TaskExplorer.Data;
using System.IO;
using System.Xml;

namespace TaskExplorer
{
    public partial class Form1 : Form
    {
        Store _store;
        bool _updating = false;
        string _currentFile = null;

        public Form1(Store tasks)
        {
            InitializeComponent();

            _store = tasks;
            UpdateFromStore();
        }

        private void UpdateFromStore()
        {
            try
            {
                _updating = true;
                goalTree.Nodes.Clear();
                taskTree.Items.Clear();
                foreach (Goal goal in _store.Goals)
                {
                    TreeNode thisNode = goalTree.Nodes.Add(goal.Name);
                    thisNode.Tag = goal;
                    foreach (Task task in goal.RequiredTasks)
                    {
                        recursivelyAddTaskToGoal(task, thisNode.Nodes);
                    }
                    thisNode.Expand();
                }

                foreach (Task task in _store.Tasks)
                {
                    addTaskToList(task, taskTree);
                }
            }
            finally
            {
                _updating = false;
            }

            if (_currentFile != null)
            {
                this.Text = _currentFile;
                saveToCurrentFile();
            }
        }

        private static void addTaskToList(Task task, ListView list)
        {
            ListViewItem thisItem = list.Items.Add(task.Name);
            thisItem.Tag = task;
            thisItem.Checked = task.IsComplete;
        }

        private void recursivelyAddTaskToGoal(Task task, TreeNodeCollection nodes)
        {
            TreeNode thisNode = addTaskToGoal(task, nodes);
            foreach (Task subTask in task.PreRequisites)
            {
                recursivelyAddTaskToGoal(subTask, thisNode.Nodes);
            }
        }

        private static TreeNode addTaskToGoal(Task task, TreeNodeCollection nodes)
        {
            TreeNode thisNode = nodes.Add(task.Name);
            thisNode.Tag = task;
            return thisNode;
        }

        private void taskTree_ItemChecked(object sender, ItemCheckedEventArgs e)
        {
            if (!_updating)
            {
                Task task = (Task)e.Item.Tag;
                task.IsComplete = e.Item.Checked;
                saveToCurrentFile();
            }
        }

        private void button1_Click(object sender, EventArgs e)
        {
            _store.CreateGoal(newGoalName.Text);
            UpdateFromStore();
            newGoalName.Text = "";
        }

        private void button2_Click(object sender, EventArgs e)
        {
            _store.CreateTask(newTaskName.Text);
            UpdateFromStore();
            newTaskName.Text = "";
        }

        private void taskTree_ItemDrag(object sender, ItemDragEventArgs e)
        {
            taskTree.DoDragDrop(e.Item, DragDropEffects.Link);
        }

        private void goalTree_DragEnter(object sender, DragEventArgs e)
        {
            e.Effect = DragDropEffects.Link;
        }

        private void goalTree_DragDrop(object sender, DragEventArgs e)
        {
            bool needUpdate = false;

            if (e.Data.GetDataPresent("System.Windows.Forms.ListViewItem", false))
            {
                ListViewItem droppedNode = (ListViewItem) e.Data.GetData("System.Windows.Forms.ListViewItem", false);

                Point pt;
                TreeNode droppedOn;
                TreeView droppedOnTree = ((TreeView)sender);
                pt = droppedOnTree.PointToClient(new Point(e.X, e.Y));
                droppedOn = droppedOnTree.GetNodeAt(pt);

                if (droppedNode.ListView == taskTree)
                {
                    Goal goal = (Goal)droppedOn.Tag;
                    Task task = (Task)droppedNode.Tag;

                    goal.RequireTask(task);
                    needUpdate = true;
                }
                else
                {
                    throw new NotImplementedException("not yet");
                }
            }

            if (needUpdate)
            {
                UpdateFromStore();
            }
        }

        private void openToolStripMenuItem_Click(object sender, EventArgs e)
        {
            OpenFileDialog dlg = new OpenFileDialog();
            dlg.Filter = "Task files (*.tasks)|*.tasks|All files (*.*)|*.*";
            if (dlg.ShowDialog() == DialogResult.OK)
            {
                Stream input = dlg.OpenFile();
                try
                {
                    XmlDocument doc = new XmlDocument();
                    doc.Load(input);
                    _store.LoadFrom(doc);
                    UpdateFromStore();
                    _currentFile = dlg.FileName;
                }
                finally
                {
                    input.Close();
                }
            }
        }

        private void saveToCurrentFile()
        {
            if (_currentFile != null)
            {
                XmlWriterSettings setts = new XmlWriterSettings();
                setts.Indent = true;
                using (XmlWriter writer = XmlWriter.Create(_currentFile, setts))
                {
                    _store.SaveTo(writer);
                }
                showTransientMsg("Saved " + _currentFile);
            }
        }

        private void showTransientMsg(string msg)
        {
            // XXX time out the message
            toolStripStatusLabel1.Text = msg;
            Timer sbTimer = new Timer();
            sbTimer.Interval = 2000; // 2s timeout
            sbTimer.Tick += clearStatusBar;
            sbTimer.Start();
        }

        void clearStatusBar(object sender, EventArgs e)
        {
            ((Timer)sender).Stop();
            toolStripStatusLabel1.Text = "";
        }

        private void saveAsToolStripMenuItem_Click(object sender, EventArgs e)
        {
            SaveFileDialog dlg = new SaveFileDialog();
            dlg.DefaultExt = ".tasks";
            if (dlg.ShowDialog() == DialogResult.OK)
            {
                Stream output = dlg.OpenFile();
                try
                {
                    XmlWriterSettings setts = new XmlWriterSettings();
                    setts.Indent = true;
                    using (XmlWriter writer = XmlWriter.Create(output, setts))
                    {
                        _store.SaveTo(writer);
                    }
                    _currentFile = dlg.FileName;
                }
                finally
                {
                    output.Close();
                }
            }
        }

        private void taskTree_SelectedIndexChanged(object sender, EventArgs e)
        {
            ListView view = (ListView)sender;
            if (view.SelectedItems.Count == 1)
            {
                Task selectedTask = (Task)view.SelectedItems[0].Tag;
                setTaskView(selectedTask);
            }
            else
            {
                resetTaskView();
            }
        }

        private void resetTaskView()
        {
            taskPreReqs.Clear();
            taskIncludes.Clear();
        }

        private void setTaskView(Task selectedTask)
        {
            taskPreReqs.Clear();
            foreach (Task task in selectedTask.PreRequisites)
            {
                addTaskToList(task, taskPreReqs);
            }
            taskIncludes.Clear();
            foreach (Task task in selectedTask.Requisites)
            {
                addTaskToList(task, taskIncludes);
            }
        }
    }
}