using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows.Controls;
using HeuristicLab.BackgroundProcessing;
using System.Windows;
using System.IO.Compression;
using System.IO;
using HeuristicLab.MainForm.WPF;
using HeuristicLab.MainForm;
using System.ComponentModel;
using System.Data;
using System.Windows.Data;
using Microsoft.Windows.Controls;
using HeuristicLab.OKB.Client;
using HeuristicLab.OKB.Cockpit.Admin.OKBTables;

namespace HeuristicLab.OKB.Cockpit.Admin {

  public partial class TableView : UserControl, IView, IOKBCockpitItem {

    static DependencyProperty TableNameProperty =
      DependencyProperty.Register("TableName", typeof(string), typeof(TableView),
      new PropertyMetadata("<no table>"));

    private DataTable table;
    private Dictionary<string, DataTable> foreignKeys;

    public TableView() {
      InitializeComponent();
      Data.Items.Clear();
      Data.Columns.Clear();
    }

    public string TableName {
      get {
        return (string)GetValue(TableNameProperty);
      }
      set {
        SetValue(TableNameProperty, value);
      }
    }

    protected override void OnPropertyChanged(DependencyPropertyChangedEventArgs e) {
      base.OnPropertyChanged(e);
      if (e.Property == TableNameProperty) {
        if (CaptionChanged != null)
          CaptionChanged(this, new EventArgs());
        OnLoad(this, new EventArgs());
      }
    }

    #region IView Members

    public string Caption {
      get { return "Table View: " + TableName; }
      set { throw new NotSupportedException(); }
    }
    public event EventHandler CaptionChanged;
    public event EventHandler Changed;
    public virtual void Close() {
      MainFormManager.GetMainForm<WPFMainFormBase>().CloseView(this);
      IsShown = false;
    }

    public void Hide() {
      MainFormManager.GetMainForm<WPFMainFormBase>().HideView(this);
      IsShown = false;
    }

    public bool IsShown { get; protected set; }

    private bool readOnly = false;
    public bool ReadOnly {
      get {
        return readOnly;
      }
      set {
        if (value == readOnly) return;
        readOnly = value;
        OnReadOnlyChanged();
      }
    }
    public event EventHandler ReadOnlyChanged;
    protected void OnReadOnlyChanged() {
      EventHandler handler = ReadOnlyChanged;
      if (handler != null)
        handler(this, EventArgs.Empty);
    }

    public void Show() {
      MainFormManager.GetMainForm<WPFMainFormBase>().ShowView(this);
      IsShown = true;
    }


    #endregion

    protected void OnLoad(object sender, EventArgs args) {
      if (TableName == null) {
        MessageBox.Show("No table name given", Caption);
        return;
      }
      var loader = new TableLoadWorker(TableName, true);
      loader.RunWorkerCompleted += (s, a) => {
        if (loader.Table == null) {
          MessageBox.Show("Table loading failed", Caption);
          return;
        }
        foreignKeys = loader.ForeignKeys;
        table = loader.Table;
        table.AcceptChanges();
        Data.ItemsSource = null;
        Data.Items.Clear();
        Data.Columns.Clear();
        Data.DataContext = table;
        Data.SetBinding(DataGrid.ItemsSourceProperty, new Binding());
        Data.ContextMenu = null;
        if (table.TableName == "Algorithm" || table.TableName == "Problem") {
          MenuItem edit = new MenuItem() { Header = "Edit Operator Graph" };
          edit.Click += OnEditOperatorGraphClicked;
          Data.ContextMenu = new ContextMenu();
          Data.ContextMenu.Items.Add(edit);
        }
      };
      loader.RunWorkerAsync(TableName);
    }

    private string DataRowValueToString(object o) {
      if (o == DBNull.Value)
        return null;
      return o as string;
    }

    protected void OnEditOperatorGraphClicked(object sender, RoutedEventArgs args) {
      if (Data.SelectedCells.Count == 0)
        return;
      DataRowView view = Data.SelectedCells.First().Item as DataRowView;
      if (view == null)
        return;
      DataRow row = view.Row;
      if (row["Id"] == DBNull.Value) {
        MessageBox.Show(string.Format("Cannot edit newly created {0} as it has no id yet."
          + Environment.NewLine +
          "upload your changes to the database first", table.TableName), Caption, MessageBoxButton.OK, MessageBoxImage.Error);
        return;
      }
      if (table.TableName == "Problem")
        MainFormManager.GetMainForm<CockpitMainWindow>().ShowView(new ProblemEditor() {
          Problem = new OKBAdmin.Problem() {
            Id = (int)row["Id"],
            Name = (string)row["Name"],
            Description = DataRowValueToString(row["Description"]),
          }
        });
      else if (table.TableName == "Algorithm")
        MainFormManager.GetMainForm<CockpitMainWindow>().ShowView(new AlgorithmEditor() {
          Algorithm = new OKBAdmin.Algorithm() {
            Id = (int)row["Id"],
            Name = (string)row["Name"],
            Description = DataRowValueToString(row["Description"]),
          }
        });
    }

    protected void OnSave(object sender, EventArgs args) {
      var saver = new ObservableBackgroundWorker("uploading changes");
      DataTable updatedRows = table.GetChanges(DataRowState.Added | DataRowState.Modified);
      DataTable deletedRows = table.GetChanges(DataRowState.Deleted);
      bool success = false;
      saver.DoWork += (s, a) => {
        TableServiceClient client = ClientFactory.Create<TableServiceClient, ITableService>();
        if (updatedRows != null)
          client.UpdateDataTable(updatedRows, (string)a.Argument);
        if (deletedRows != null)
          client.DeleteTableRows(
            deletedRows.Rows.Cast<DataRow>()
              .Select(r => (int)r["Id", DataRowVersion.Original]).ToList(),
            (string)a.Argument);
        success = true;
      };
      saver.RunWorkerCompleted += (s, a) => {
        if (success) {
          table.AcceptChanges();
        }
        OnLoad(sender, args);
      };
      saver.RunWorkerAsync(TableName);
    }

    protected void OnAutoGeneratingColumn(object source, DataGridAutoGeneratingColumnEventArgs args) {
      if (args.Column.Header as string == "Id") {
        args.Cancel = true;
        return;
      }
      if (foreignKeys.ContainsKey(args.PropertyName)) {
        DataTable referencedTable = foreignKeys[args.PropertyName];
        args.Column = new DataGridComboBoxColumn() {
          Header = referencedTable.TableName,
          ItemsSource = referencedTable.DefaultView,
          SelectedValuePath = "Id",
          DisplayMemberPath = referencedTable.Columns.Contains("Name") ? "Name" : "ClrName",
          SelectedValueBinding = new Binding(args.PropertyName),
        };
      }
    }

    private void CommandBinding_Executed(object sender, System.Windows.Input.ExecutedRoutedEventArgs e) {
      OnSave(sender, e);
    }
  }
}