/*
 * Copyright 2000-2012 JetBrains s.r.o.
 *
 * 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.
 */
package com.intellij.util.ui;

import com.intellij.openapi.actionSystem.AnActionEvent;
import com.intellij.openapi.actionSystem.CustomShortcutSet;
import com.intellij.openapi.application.ApplicationBundle;
import com.intellij.openapi.util.NullableComputable;
import com.intellij.openapi.util.Pair;
import com.intellij.openapi.wm.IdeFocusManager;
import com.intellij.ui.AnActionButton;
import com.intellij.ui.AnActionButtonRunnable;
import com.intellij.ui.HoverHyperlinkLabel;
import com.intellij.ui.ToolbarDecorator;
import com.intellij.ui.table.TableView;
import com.intellij.util.IconUtil;
import org.jetbrains.annotations.NonNls;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;

import javax.swing.*;
import javax.swing.event.HyperlinkEvent;
import javax.swing.event.HyperlinkListener;
import javax.swing.event.ListSelectionEvent;
import javax.swing.event.ListSelectionListener;
import javax.swing.table.DefaultTableCellRenderer;
import javax.swing.table.JTableHeader;
import javax.swing.table.TableCellEditor;
import javax.swing.table.TableCellRenderer;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.KeyEvent;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public abstract class ValidatingTableEditor<Item> implements ComponentWithEmptyText {

  private static final Icon WARNING_ICON = UIUtil.getBalloonWarningIcon();
  private static final Icon EMPTY_ICON = EmptyIcon.create(WARNING_ICON);
  @NonNls private static final String REMOVE_KEY = "REMOVE_SELECTED";

  public interface RowHeightProvider {
    int getRowHeight();
  }

  public interface Fix extends Runnable {
    String getTitle();
  }

  private class ColumnInfoWrapper extends ColumnInfo<Item, Object> {
    private final ColumnInfo<Item, Object> myDelegate;

    public ColumnInfoWrapper(ColumnInfo<Item, Object> delegate) {
      super(delegate.getName());
      myDelegate = delegate;
    }

    @Override
    public Object valueOf(Item item) {
      return myDelegate.valueOf(item);
    }

    @Override
    public boolean isCellEditable(Item item) {
      return myDelegate.isCellEditable(item);
    }

    @Override
    public void setValue(Item item, Object value) {
      myDelegate.setValue(item, value);
      updateMessage(-1, null);
    }

    @Override
    public TableCellEditor getEditor(Item item) {
      return myDelegate.getEditor(item);
    }

    @Override
    public int getWidth(JTable table) {
      return myDelegate.getWidth(table);
    }

    @Override
    public Class getColumnClass() {
      return myDelegate.getColumnClass();
    }

    @Override
    public TableCellRenderer getRenderer(Item item) {
      return myDelegate.getRenderer(item);
    }
  }

  private JPanel myContentPane;
  private TableView<Item> myTable;
  private AnActionButton myRemoveButton;
  private JLabel myMessageLabel;
  private HoverHyperlinkLabel myFixLink;
  private JPanel myTablePanel;
  private final List<String> myWarnings = new ArrayList<String>();
  private Fix myFixRunnable;

  protected abstract Item cloneOf(Item item);

  @Nullable
  protected Pair<String, Fix> validate(List<Item> current, List<String> warnings) {
    String error = null;
    for (int i = 0; i < current.size(); i++) {
      Item item = current.get(i);
      String s = validate(item);
      warnings.set(i, s);
      if (error == null) {
        error = s;
      }
    }
    return error != null ? Pair.create(error, (Fix)null) : null;
  }

  @Nullable
  protected String validate(Item item) {
    return null;
  }

  @Nullable
  protected abstract Item createItem();

  private class IconColumn extends ColumnInfo<Item, Object> implements RowHeightProvider {
    public IconColumn() {
      super(" ");
    }

    public String valueOf(Item item) {
      return null;
    }

    @Override
    public int getWidth(JTable table) {
      return WARNING_ICON.getIconWidth() + 2;
    }

    public int getRowHeight() {
      return WARNING_ICON.getIconHeight();
    }

    @Override
    public TableCellRenderer getRenderer(final Item item) {
      return new WarningIconCellRenderer(new NullableComputable<String>() {
        public String compute() {
          return myWarnings.get(doGetItems().indexOf(item));
        }
      });
    }
  }

  @NotNull
  @Override
  public StatusText getEmptyText() {
    return myTable.getEmptyText();
  }

  private void createUIComponents() {
    myTable = new ChangesTrackingTableView<Item>() {
      protected void onCellValueChanged(int row, int column, Object value) {
        final Item original = getItems().get(row);
        Item override = cloneOf(original);
        final ColumnInfo<Item, Object> columnInfo = getTableModel().getColumnInfos()[column];
        columnInfo.setValue(override, value);
        updateMessage(row, override);
      }

      @Override
      protected void onEditingStopped() {
        updateMessage(-1, null);
      }
    };

    myFixLink = new HoverHyperlinkLabel(null);
  }

  protected ValidatingTableEditor(@Nullable AnActionButton ... extraButtons) {
    ToolbarDecorator decorator =
      ToolbarDecorator.createDecorator(myTable).disableRemoveAction().disableUpAction().disableDownAction();
    decorator.setAddAction(new AnActionButtonRunnable() {

      @Override
      public void run(AnActionButton anActionButton) {
        addItem();
      }
    });


    myRemoveButton = new AnActionButton(ApplicationBundle.message("button.remove"), IconUtil.getRemoveIcon()) {
      @Override
      public void actionPerformed(AnActionEvent e) {
        removeSelected();
      }
    };
    myRemoveButton.setShortcut(CustomShortcutSet.fromString("alt DELETE")); //NON-NLS
    decorator.addExtraAction(myRemoveButton);

    if (extraButtons != null &&  extraButtons.length != 0) {
      for (AnActionButton extraButton : extraButtons) {
        decorator.addExtraAction(extraButton);
      }
    }

    myTablePanel.add(decorator.createPanel(), BorderLayout.CENTER);

    myTable.getSelectionModel().addListSelectionListener(new ListSelectionListener() {
      public void valueChanged(ListSelectionEvent e) {
        updateButtons();
      }
    });

    myTable.getInputMap(JComponent.WHEN_FOCUSED).put(KeyStroke.getKeyStroke(KeyEvent.VK_DELETE, 0), REMOVE_KEY);
    myTable.getActionMap().put(REMOVE_KEY, new AbstractAction() {
      public void actionPerformed(final ActionEvent e) {
        removeSelected();
      }
    });

    myFixLink.addHyperlinkListener(new HyperlinkListener() {
      public void hyperlinkUpdate(HyperlinkEvent e) {
        if (e.getEventType() == HyperlinkEvent.EventType.ACTIVATED && myFixRunnable != null) {
          myFixRunnable.run();
        }
      }
    });
  }

  protected ValidatingTableEditor() {
    //noinspection NullArgumentToVariableArgMethod
    this(null);
  }

  @Nullable
  public List<Item> getSelectedItems() {
    return myTable.getSelectedObjects();
  }

  private void removeSelected() {
    myTable.stopEditing();
    List<Item> items = new ArrayList<Item>(doGetItems());
    final int[] rows = myTable.getSelectedRows();
    for (int i = rows.length - 1; i >= 0; i--) {
      items.remove(rows[i]);
    }

    setItems(items);
    updateMessage(-1, null);

    if (!items.isEmpty()) {
      int index = Math.min(rows[0], items.size() - 1);
      myTable.getSelectionModel().addSelectionInterval(index, index);
    }
  }

  protected void addItem() {
    Item newItem = createItem();
    if (newItem == null) {
      return;
    }
    List<Item> items = new ArrayList<Item>(doGetItems());
    items.add(newItem);

    setItems(items);

    final int row = items.size() - 1;
    myTable.getSelectionModel().setSelectionInterval(row, row);
    myTable.scrollRectToVisible(myTable.getCellRect(row, 0, true));
    if (getTableModel().getColumnInfos()[1].isCellEditable(items.get(row))) {
      myTable.editCellAt(row, 1);
      IdeFocusManager.findInstanceByComponent(myContentPane).requestFocus(myTable.getEditorComponent(), true);
    }
    updateMessage(-1, null);
  }

  private ListTableModel<Item> getTableModel() {
    return (ListTableModel<Item>)myTable.getModel();
  }

  public void setModel(ColumnInfo<Item, Object>[] valueColumns, List<Item> items) {
    ColumnInfo[] columns = new ColumnInfo[valueColumns.length + 1];
    IconColumn iconColumn = new IconColumn();
    int maxHeight = iconColumn.getRowHeight();

    columns[0] = iconColumn;
    for (int i = 0; i < valueColumns.length; i++) {
      columns[i + 1] = new ColumnInfoWrapper(valueColumns[i]);
      if (valueColumns[i] instanceof RowHeightProvider) {
        maxHeight = Math.max(maxHeight, ((RowHeightProvider)valueColumns[i]).getRowHeight());
      }
    }

    myTable.stopEditing();
    myTable.setModelAndUpdateColumns(new ListTableModel<Item>(columns));
    if (maxHeight > 0) {
      myTable.setRowHeight(maxHeight);
    }

    setItems(items);
    updateMessage(-1, null);
  }

  public List<Item> getItems() {
    return Collections.unmodifiableList(doGetItems());
  }

  private List<Item> doGetItems() {
    List<Item> items = new ArrayList<Item>(getTableModel().getItems());
    if (myTable.isEditing()) {
      Object value = ChangesTrackingTableView.getValue(myTable.getEditorComponent());
      ColumnInfo column = ((ListTableModel)myTable.getModel()).getColumnInfos()[myTable.getEditingColumn()];
      ((ColumnInfoWrapper)column).myDelegate.setValue(items.get(myTable.getEditingRow()), value);
    }
    return items;
  }

  private void setItems(List<Item> items) {
    if (items.isEmpty()) {
      getTableModel().setItems(Collections.<Item>emptyList());
      myWarnings.clear();
    }
    else {
      myWarnings.clear();
      for (Item item : items) {
        myWarnings.add(null);
      }
      getTableModel().setItems(new ArrayList<Item>(items));
    }
    updateButtons();
  }

  public void setTableHeader(JTableHeader header) {
    myTable.setTableHeader(header);
  }

  private void updateButtons() {
    myRemoveButton.setEnabled(myTable.getSelectedRow() != -1);
  }

  public void updateMessage(int index, @Nullable Item override) {
    List<Item> current = new ArrayList<Item>(doGetItems());
    if (override != null) {
      current.set(index, override);
    }

    displayMessageAndFix(validate(current, myWarnings));
    myTable.repaint();
  }

  protected void displayMessageAndFix(@Nullable Pair<String, Fix> messageAndFix) {
    if (messageAndFix != null) {
      myMessageLabel.setText(messageAndFix.first);
      myMessageLabel.setIcon(WARNING_ICON);
      myMessageLabel.setVisible(true);
      myFixRunnable = messageAndFix.second;
      myFixLink.setVisible(myFixRunnable != null);
      myFixLink.setText(myFixRunnable != null ? myFixRunnable.getTitle() : null);
    }
    else {
      myMessageLabel.setText(" ");
      myMessageLabel.setIcon(EMPTY_ICON);
      myFixLink.setVisible(false);
      myFixRunnable = null;
    }
  }

  public void hideMessageLabel() {
    myMessageLabel.setVisible(false);
    myFixLink.setVisible(false);
  }

  public JComponent getPreferredFocusedComponent() {
    return myTable;
  }


  private static class WarningIconCellRenderer extends DefaultTableCellRenderer {
    private final NullableComputable<String> myWarningProvider;

    public WarningIconCellRenderer(NullableComputable<String> warningProvider) {
      myWarningProvider = warningProvider;
    }

    @Override
    public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column) {
      JLabel label = (JLabel)super.getTableCellRendererComponent(table, value, isSelected, hasFocus, row, column);
      String message = myWarningProvider.compute();
      label.setIcon(message != null ? WARNING_ICON : null);
      label.setToolTipText(message);
      label.setHorizontalAlignment(CENTER);
      label.setVerticalAlignment(CENTER);
      return label;
    }
  }

  public Component getContentPane() {
    return myContentPane;
  }

  public void setColumnReorderingAllowed(boolean value) {
    JTableHeader header = myTable.getTableHeader();
    if (header != null) {
      header.setReorderingAllowed(value);
    }
  }
}
