/*
 * 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.
 */

/*
 * Class BreakpointPropertiesPanel
 * @author Jeka
 */
package com.intellij.debugger.ui.breakpoints;

import com.intellij.debugger.DebuggerManagerEx;
import com.intellij.debugger.InstanceFilter;
import com.intellij.debugger.engine.evaluation.CodeFragmentKind;
import com.intellij.debugger.engine.evaluation.DefaultCodeFragmentFactory;
import com.intellij.debugger.engine.evaluation.TextWithImportsImpl;
import com.intellij.debugger.settings.DebuggerSettings;
import com.intellij.debugger.ui.CompletionEditor;
import com.intellij.debugger.ui.DebuggerExpressionComboBox;
import com.intellij.debugger.ui.DebuggerStatementEditor;
import com.intellij.debugger.ui.JavaDebuggerSupport;
import com.intellij.ide.util.ClassFilter;
import com.intellij.openapi.editor.event.DocumentEvent;
import com.intellij.openapi.editor.event.DocumentListener;
import com.intellij.openapi.project.Project;
import com.intellij.openapi.ui.DialogWrapper;
import com.intellij.openapi.ui.FixedSizeButton;
import com.intellij.openapi.util.Key;
import com.intellij.openapi.util.text.StringUtil;
import com.intellij.openapi.wm.IdeFocusManager;
import com.intellij.psi.PsiClass;
import com.intellij.psi.PsiElement;
import com.intellij.ui.FieldPanel;
import com.intellij.ui.MultiLineTooltipUI;
import com.intellij.ui.popup.util.DetailView;
import com.intellij.util.IJSwingUtilities;
import com.intellij.xdebugger.impl.DebuggerSupport;
import com.intellij.xdebugger.impl.breakpoints.ui.BreakpointChooser;
import com.intellij.xdebugger.impl.breakpoints.ui.BreakpointItem;
import com.intellij.xdebugger.impl.breakpoints.ui.BreakpointNoneItem;
import com.intellij.xdebugger.impl.ui.DebuggerUIUtil;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;

import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public abstract class BreakpointPropertiesPanel {

  private BreakpointChooser myMasterBreakpointChooser;

  public void setDetailView(DetailView detailView) {
    myMasterBreakpointChooser.setDetailView(detailView);
  }

  protected final Project myProject;
  private final Key<? extends Breakpoint> myBreakpointCategory;
  private boolean myCompact;
  private JPanel myPanel;
  private final DebuggerExpressionComboBox myConditionCombo;
  private final DebuggerExpressionComboBox myLogExpressionCombo;
  private JTextField myPassCountField;
  private final FieldPanel myInstanceFiltersField;

  private final FieldPanel myClassFiltersField;
  private com.intellij.ui.classFilter.ClassFilter[] myClassFilters;
  private com.intellij.ui.classFilter.ClassFilter[] myClassExclusionFilters;
  private InstanceFilter[] myInstanceFilters;

  private JCheckBox myLogExpressionCheckBox;
  private JCheckBox myLogMessageCheckBox;
  protected JCheckBox myPassCountCheckbox;
  private JCheckBox myInstanceFiltersCheckBox;
  private JCheckBox myClassFiltersCheckBox;

  private JPanel myInstanceFiltersFieldPanel;
  private JPanel myClassFiltersFieldPanel;
  private JPanel myConditionComboPanel;
  private JPanel myLogExpressionComboPanel;
  private JPanel myDependentBreakpointComboPanel;
  private JPanel mySpecialBoxPanel;
  private PsiClass myBreakpointPsiClass;

  private JRadioButton myRbSuspendThread;
  private JRadioButton myRbSuspendAll;
  private JCheckBox myCbSuspend;
  private JButton myMakeDefaultButton;

  private JRadioButton myDisableAgainRadio;
  private JRadioButton myLeaveEnabledRadioButton;

  private JLabel myEnableOrDisableLabel;
  private JPanel myDependsOnPanel;
  private JPanel myInstanceFiltersPanel;
  private JPanel myClassFiltersPanel;
  private JPanel myPassCountPanel;
  private JPanel myConditionsPanel;
  private JPanel myActionsPanel;
  private JCheckBox myConditionCheckbox;
  private JCheckBox myTemporaryCheckBox;
  private JCheckBox myEnabledCheckbox;

  ButtonGroup mySuspendPolicyGroup;
  public static final String CONTROL_LOG_MESSAGE = "logMessage";
  private final FixedSizeButton myConditionMagnifierButton;
  private boolean myMoreOptionsVisible = true;
  private Breakpoint myBreakpoint;

  public boolean isSaveOnRemove() {
    return mySaveOnRemove;
  }

  public void setSaveOnRemove(boolean saveOnRemove) {
    mySaveOnRemove = saveOnRemove;
  }

  private boolean mySaveOnRemove = false;

  public boolean isMoreOptionsVisible() {
    return myMoreOptionsVisible;
  }

  private void createUIComponents() {
    myPanel = new JPanel() {
      @Override
      public void removeNotify() {
        super.removeNotify();
        if (mySaveOnRemove) {
          saveTo(myBreakpoint, new Runnable() {
            @Override
            public void run() {}
          });
        }
      }
    };
  }

  public interface Delegate {

    void showActionsPanel();
  }
  private Delegate myDelegate;

  public JComponent getControl(String control) {
    if(CONTROL_LOG_MESSAGE.equals(control)) {
      return myLogExpressionCombo;
    }
    return null;
  }

  public void dispose() {
    if (myConditionCombo != null) {
      myConditionCombo.dispose();
    }
    if (myLogExpressionCombo != null) {
      myLogExpressionCombo.dispose();
    }
  }

  public void setActionsPanelVisible(boolean b) {
    myActionsPanel.setVisible(b);
  }

  public void setMoreOptionsVisible(boolean b) {
    myMoreOptionsVisible = b;
    myDependsOnPanel.setVisible(b);
    myConditionsPanel.setVisible(b);
    if (b) {
      myActionsPanel.setVisible(true);
    }
    if (!b) {
      myPanel.setPreferredSize(new Dimension(500, -1));
    }
  }

  public void setDelegate(Delegate delegate) {
    myDelegate = delegate;
  }

  private class MyTextField extends JTextField {
    public MyTextField() {
    }

    @Override
    public String getToolTipText(MouseEvent event) {
      reloadClassFilters();
      updateClassFilterEditor(false);
      reloadInstanceFilters();
      updateInstanceFilterEditor(false);
      String toolTipText = super.getToolTipText(event);
      return getToolTipText().length() == 0 ? null : toolTipText;
    }

    @Override
    public JToolTip createToolTip() {
      JToolTip toolTip = new JToolTip(){{
        setUI(new MultiLineTooltipUI());
      }};
      toolTip.setComponent(this);
      return toolTip;
    }
  }

  private static void insert(JPanel panel, JComponent component) {
    panel.setLayout(new BorderLayout());
    panel.add(component, BorderLayout.CENTER);
  }

  public BreakpointPropertiesPanel(final Project project, final Key<? extends Breakpoint> breakpointCategory, boolean compact) {
    myProject = project;
    myBreakpointCategory = breakpointCategory;
    myCompact = compact;

    mySuspendPolicyGroup = new ButtonGroup();
    mySuspendPolicyGroup.add(myRbSuspendAll);
    mySuspendPolicyGroup.add(myRbSuspendThread);

    updateSuspendPolicyRbFont();
    final ItemListener suspendPolicyChangeListener = new ItemListener() {
      @Override
      public void itemStateChanged(final ItemEvent e) {
        final BreakpointDefaults defaults = getBreakpointManager(myProject).getBreakpointDefaults(breakpointCategory);
        myMakeDefaultButton.setEnabled(!defaults.getSuspendPolicy().equals(getSelectedSuspendPolicy()) || defaults.isConditionEnabled() != myConditionCheckbox.isSelected());
      }
    };

    myCbSuspend.addActionListener(new ActionListener() {
      @Override
      public void actionPerformed(ActionEvent event) {
        final boolean enabled = myCbSuspend.isSelected();
        myRbSuspendAll.setEnabled(enabled);
        myRbSuspendThread.setEnabled(enabled);
      }
    });


    myRbSuspendAll.addItemListener(suspendPolicyChangeListener);
    myRbSuspendThread.addItemListener(suspendPolicyChangeListener);
    myConditionCheckbox.addItemListener(suspendPolicyChangeListener);

    myMakeDefaultButton.addActionListener(new ActionListener() {
      @Override
      public void actionPerformed(final ActionEvent e) {
        final BreakpointManager breakpointManager = getBreakpointManager(myProject);
        final String suspendPolicy = getSelectedSuspendPolicy();
        breakpointManager.setBreakpointDefaults(breakpointCategory, new BreakpointDefaults(suspendPolicy, myConditionCheckbox.isSelected()));
        updateSuspendPolicyRbFont();
        if (DebuggerSettings.SUSPEND_THREAD.equals(suspendPolicy)) {
          myRbSuspendThread.requestFocus();
        }
        else {
          myRbSuspendAll.requestFocus();
        }
        myMakeDefaultButton.setEnabled(false);
      }
    });

    myConditionCombo = new DebuggerExpressionComboBox(project, "LineBreakpoint condition");
    myConditionCombo.addDocumentListener(new DocumentListener() {
      @Override
      public void beforeDocumentChange(DocumentEvent event) {
        myConditionCheckbox.setSelected(true);
      }

      @Override
      public void documentChanged(DocumentEvent event) {

      }
    });

    myConditionCombo.getEditorComponent().addMouseListener(new MouseAdapter() {
      @Override
      public void mouseClicked(MouseEvent event) {
        myConditionCombo.setEnabled(true);
        myConditionCheckbox.setSelected(true);
      }
    });

    if (myCompact) {
      myPanel.addFocusListener(new FocusAdapter() {
        @Override
        public void focusGained(FocusEvent event) {
          DebuggerExpressionComboBox focus;
          if (myLogExpressionCheckBox.isSelected()) {
            focus = myLogExpressionCombo;
          } else {
            focus = myConditionCombo;
          }
          IdeFocusManager.findInstance().requestFocus(focus, true);
        }
      });
    }

    myLogExpressionCombo = new DebuggerExpressionComboBox(project, "LineBreakpoint logMessage");

    myInstanceFiltersField = new FieldPanel(new MyTextField(), "", null,
     new ActionListener() {
      @Override
      public void actionPerformed(ActionEvent e) {
        reloadInstanceFilters();
        EditInstanceFiltersDialog _dialog = new EditInstanceFiltersDialog(myProject);
        _dialog.setFilters(myInstanceFilters);
        _dialog.show();
        if(_dialog.getExitCode() == DialogWrapper.OK_EXIT_CODE) {
          myInstanceFilters = _dialog.getFilters();
          updateInstanceFilterEditor(true);
        }
      }
    },
     null
    );

    myClassFiltersField = new FieldPanel(new MyTextField(), "", null,
     new ActionListener() {
      @Override
      public void actionPerformed(ActionEvent e) {
        reloadClassFilters();

        ClassFilter classFilter = createClassConditionFilter();

        EditClassFiltersDialog _dialog = new EditClassFiltersDialog(myProject, classFilter);
        _dialog.setFilters(myClassFilters, myClassExclusionFilters);
        _dialog.show();
        if (_dialog.getExitCode() == DialogWrapper.OK_EXIT_CODE) {
          myClassFilters = _dialog.getFilters();
          myClassExclusionFilters = _dialog.getExclusionFilters();
          updateClassFilterEditor(true);
        }
      }
    },
     null
    );
    ToolTipManager.sharedInstance().registerComponent(myClassFiltersField.getTextField());
    ToolTipManager.sharedInstance().registerComponent(myInstanceFiltersField.getTextField());

    JComponent specialBox = createSpecialBox();
    if(specialBox != null) {
      insert(mySpecialBoxPanel, specialBox);
    } 
    else {
      mySpecialBoxPanel.setVisible(false);
    }

    final JPanel conditionPanel = new JPanel(new BorderLayout());
    conditionPanel.add(myConditionCombo, BorderLayout.CENTER);
    myConditionMagnifierButton = new FixedSizeButton(myConditionCombo);
    conditionPanel.add(myConditionMagnifierButton, BorderLayout.EAST);
    myConditionMagnifierButton.setFocusable(false);
    myConditionMagnifierButton.addActionListener(new MagnifierButtonAction(project, myConditionCombo, "Condition"));

    insert(myConditionComboPanel, conditionPanel);
    insert(myLogExpressionComboPanel, myLogExpressionCombo);

    insert(myInstanceFiltersFieldPanel, myInstanceFiltersField);
    insert(myClassFiltersFieldPanel, myClassFiltersField);

    DebuggerUIUtil.enableEditorOnCheck(myLogExpressionCheckBox, myLogExpressionCombo);
    ActionListener updateListener = new ActionListener() {
      @Override
      public void actionPerformed(ActionEvent e) {
        updateCheckboxes();
      }
    };

    myPassCountCheckbox.addActionListener(new ActionListener() {
      @Override
      public void actionPerformed(ActionEvent event) {
        if (myPassCountCheckbox.isSelected()) {
          myConditionCheckbox.setSelected(false);
        }
        updateCheckboxes();
      }
    });
    myInstanceFiltersCheckBox.addActionListener(updateListener);
    myClassFiltersCheckBox.addActionListener(updateListener);
    myConditionCheckbox.addActionListener(new ActionListener() {
      @Override
      public void actionPerformed(ActionEvent event) {
        if (myConditionCheckbox.isSelected()) {
          myPassCountCheckbox.setSelected(false);
        }
        updateCheckboxes();
      }
    });
    DebuggerUIUtil.focusEditorOnCheck(myPassCountCheckbox, myPassCountField);
    DebuggerUIUtil.focusEditorOnCheck(myLogExpressionCheckBox, myLogExpressionCombo);
    DebuggerUIUtil.focusEditorOnCheck(myInstanceFiltersCheckBox, myInstanceFiltersField.getTextField());
    DebuggerUIUtil.focusEditorOnCheck(myClassFiltersCheckBox, myClassFiltersField.getTextField());
    DebuggerUIUtil.focusEditorOnCheck(myConditionCheckbox, myConditionCombo);

    IJSwingUtilities.adjustComponentsOnMac(myCbSuspend);
    IJSwingUtilities.adjustComponentsOnMac(myLogExpressionCheckBox);
    IJSwingUtilities.adjustComponentsOnMac(myLogMessageCheckBox);
    IJSwingUtilities.adjustComponentsOnMac(myTemporaryCheckBox);
    IJSwingUtilities.adjustComponentsOnMac(myEnabledCheckbox);
  }

  private List<BreakpointItem> getBreakpointItemsExceptMy() {
    List<BreakpointItem> items = new ArrayList<BreakpointItem>();
    final DebuggerSupport support = DebuggerSupport.getDebuggerSupport(JavaDebuggerSupport.class);
    support.getBreakpointPanelProvider().provideBreakpointItems(myProject, items);
    for (BreakpointItem item : items) {
      if (item.getBreakpoint() == myBreakpoint) {
        items.remove(item);
        break;
      }
    }
    items.add(new BreakpointNoneItem());
    return items;
  }

  private void saveMasterBreakpoint() {
    Breakpoint masterBreakpoint = (Breakpoint)myMasterBreakpointChooser.getSelectedBreakpoint();
    if (masterBreakpoint == null) {
      getBreakpointManager(myProject).removeBreakpointRule(myBreakpoint);
    }
    else {
      EnableBreakpointRule rule = findMasterBreakpointRule();
      boolean selected = myLeaveEnabledRadioButton.isSelected();
      if (rule != null) {
        if (rule.getMasterBreakpoint() != masterBreakpoint || rule.isLeaveEnabled() != selected) {
          getBreakpointManager(myProject).removeBreakpointRule(rule);
        }
        else {
          return;
        }
      }
      getBreakpointManager(myProject).addBreakpointRule(new EnableBreakpointRule(getBreakpointManager(myProject), masterBreakpoint, myBreakpoint, selected));
    }
  }

  private String getSelectedSuspendPolicy() {
    if (myRbSuspendThread.isSelected()) {
      return DebuggerSettings.SUSPEND_THREAD;
    }
    return DebuggerSettings.SUSPEND_ALL;
  }

  private void updateSuspendPolicyRbFont() {
    final String defPolicy = getBreakpointManager(myProject).getBreakpointDefaults(myBreakpointCategory).getSuspendPolicy();
    
    final Font font = myRbSuspendAll.getFont().deriveFont(Font.PLAIN);
    final Font boldFont = font.deriveFont(Font.BOLD);
    
    myRbSuspendAll.setFont(DebuggerSettings.SUSPEND_ALL.equals(defPolicy)? boldFont : font);
    myRbSuspendThread.setFont(DebuggerSettings.SUSPEND_THREAD.equals(defPolicy)? boldFont : font);
  }

  protected ClassFilter createClassConditionFilter() {
    ClassFilter classFilter;
    if(myBreakpointPsiClass != null) {
      classFilter = new ClassFilter() {
        @Override
        public boolean isAccepted(PsiClass aClass) {
          return myBreakpointPsiClass == aClass || aClass.isInheritor(myBreakpointPsiClass, true);
        }
      };
    }
    else {
      classFilter = null;
    }
    return classFilter;
  }

  protected JComponent createSpecialBox() {
    return null;
  }

  /**
   * Init UI components with the values from Breakpoint
   */
  public void initFrom(Breakpoint breakpoint, boolean moreOptionsVisible1) {
    myBreakpoint = breakpoint;
    boolean moreOptionsVisible = moreOptionsVisible1;
    boolean actionsPanelVisible = moreOptionsVisible1;

    initMasterBreakpointPanel();

    if (breakpoint.COUNT_FILTER > 0) {
      myPassCountField.setText(Integer.toString(breakpoint.COUNT_FILTER));
      moreOptionsVisible = true;
    }
    else {
      myPassCountField.setText("");
    }

    PsiElement context = breakpoint.getEvaluationElement();
    myPassCountCheckbox.setSelected(breakpoint.COUNT_FILTER_ENABLED);

    myConditionCheckbox.setSelected(breakpoint.CONDITION_ENABLED);

    myConditionCombo.setEnabled(breakpoint.CONDITION_ENABLED);

    myConditionCombo.setContext(context);
    myConditionCombo.setText(breakpoint.getCondition() != null ? breakpoint.getCondition() : emptyText());

    myCbSuspend.setSelected(breakpoint.SUSPEND);
    myRbSuspendThread.setEnabled(myCbSuspend.isSelected());
    myRbSuspendAll.setEnabled(myCbSuspend.isSelected());

    if(!breakpoint.SUSPEND) {
      actionsPanelVisible = true;
    }
    if(DebuggerSettings.SUSPEND_THREAD.equals(breakpoint.SUSPEND_POLICY)){
      myRbSuspendThread.setSelected(true);
    }
    else {
      myRbSuspendAll.setSelected(true);
    }

    myCbSuspend.addActionListener(new ActionListener() {
      @Override
      public void actionPerformed(ActionEvent event) {
        if (!myActionsPanel.isVisible()) {
          if (!myCbSuspend.isSelected()) {
            if (myDelegate != null) {
              myDelegate.showActionsPanel();
            }
          }
        }
        myRbSuspendThread.setEnabled(myCbSuspend.isSelected());
        myRbSuspendAll.setEnabled(myCbSuspend.isSelected());
      }
    });
    myLogMessageCheckBox.setSelected(breakpoint.LOG_ENABLED);
    myTemporaryCheckBox.setSelected(breakpoint.REMOVE_AFTER_HIT);
    myEnabledCheckbox.setSelected(breakpoint.ENABLED);
    myEnabledCheckbox.setText(breakpoint.getShortName() + " enabled");

    DebuggerManagerEx.getInstanceEx(myProject).getBreakpointManager().addBreakpointManagerListener(new BreakpointManagerListener() {
      @Override
      public void breakpointsChanged() {
        myEnabledCheckbox.setSelected(myBreakpoint.ENABLED);
      }
    });

    myEnabledCheckbox.addActionListener(new ActionListener() {
      @Override
      public void actionPerformed(ActionEvent event) {
        if (myBreakpoint.ENABLED != myEnabledCheckbox.isSelected()) {
          myBreakpoint.ENABLED = myEnabledCheckbox.isSelected();
          getBreakpointManager(myProject).fireBreakpointChanged(myBreakpoint);
          myBreakpoint.updateUI();
        }
      }
    });
    myTemporaryCheckBox.setVisible(breakpoint instanceof LineBreakpoint);
    myLogExpressionCheckBox.setSelected(breakpoint.LOG_EXPRESSION_ENABLED);
    if (breakpoint.LOG_ENABLED || breakpoint.LOG_EXPRESSION_ENABLED || (breakpoint instanceof LineBreakpoint && breakpoint.REMOVE_AFTER_HIT)) {
      actionsPanelVisible = true;
    }

    myLogExpressionCombo.setContext(context);

    if (breakpoint.getLogMessage() != null) {
      myLogExpressionCombo.setText(breakpoint.getLogMessage());
    }
    else {
      myLogExpressionCombo.setText(emptyText());
    }

    myLogExpressionCombo.setEnabled(breakpoint.LOG_EXPRESSION_ENABLED);
    if (breakpoint.LOG_EXPRESSION_ENABLED) {
      actionsPanelVisible = true;
    }

    myInstanceFiltersCheckBox.setSelected(breakpoint.INSTANCE_FILTERS_ENABLED);
    myInstanceFiltersField.setEnabled(breakpoint.INSTANCE_FILTERS_ENABLED);
    myInstanceFiltersField.getTextField().setEditable(breakpoint.INSTANCE_FILTERS_ENABLED);
    myInstanceFilters = breakpoint.getInstanceFilters();
    updateInstanceFilterEditor(true);
    if (breakpoint.INSTANCE_FILTERS_ENABLED) {
      moreOptionsVisible = true;
    }

    myClassFiltersCheckBox.setSelected(breakpoint.CLASS_FILTERS_ENABLED);
    myClassFiltersField.setEnabled(breakpoint.CLASS_FILTERS_ENABLED);
    myClassFiltersField.getTextField().setEditable(breakpoint.CLASS_FILTERS_ENABLED);
    myClassFilters = breakpoint.getClassFilters();
    myClassExclusionFilters = breakpoint.getClassExclusionFilters();
    updateClassFilterEditor(true);
    if (breakpoint.CLASS_FILTERS_ENABLED) {
      moreOptionsVisible = true;
    }

    myBreakpointPsiClass = breakpoint.getPsiClass();

    updateCheckboxes();

    setActionsPanelVisible(actionsPanelVisible && !moreOptionsVisible1);
    setMoreOptionsVisible(moreOptionsVisible);
  }

  private void initMasterBreakpointPanel() {
    final EnableBreakpointRule rule = findMasterBreakpointRule();

    final Breakpoint baseBreakpoint = rule != null ? rule.getMasterBreakpoint() : null;
    updateMasterBreakpointPanel(rule);


    myMasterBreakpointChooser = new BreakpointChooser(myProject, new BreakpointChooser.Delegate() {
      @Override
      public void breakpointChosen(Project project, BreakpointItem item) {
        final boolean enabled = item != null && item.getBreakpoint() != null;
        myLeaveEnabledRadioButton.setEnabled(enabled);
        myDisableAgainRadio.setEnabled(enabled);
        myEnableOrDisableLabel.setEnabled(enabled);

        if (item != null) {

          saveMasterBreakpoint();
        }

        updateMasterBreakpointPanel(findMasterBreakpointRule());

      }
    }, baseBreakpoint, getBreakpointItemsExceptMy());

    insert(myDependentBreakpointComboPanel, myMasterBreakpointChooser.getComponent());

  }

  private @Nullable EnableBreakpointRule findMasterBreakpointRule() {
    return myBreakpoint != null? getBreakpointManager(myProject).findBreakpointRule(myBreakpoint) : null;
  }

  private void updateMasterBreakpointPanel(@Nullable EnableBreakpointRule rule) {
    final boolean leaveEnabled = rule != null && rule.isLeaveEnabled();
    if (leaveEnabled) {
      myLeaveEnabledRadioButton.setSelected(true);
    }
    else {
      myDisableAgainRadio.setSelected(true);
    }
  }

  private static TextWithImportsImpl emptyText() {
    return new TextWithImportsImpl(CodeFragmentKind.EXPRESSION, "");
  }

  /**
   * Save values in the UI components to the breakpoint object
   */
  public void saveTo(Breakpoint breakpoint, @NotNull Runnable afterUpdate) {

    saveMasterBreakpoint();
    try {
      String text = myPassCountField.getText().trim();
      breakpoint.COUNT_FILTER = !text.isEmpty() ? Integer.parseInt(text) : 0;
      if (breakpoint.COUNT_FILTER < 0) {
        breakpoint.COUNT_FILTER = 0;
      }
    }
    catch (Exception ignored) {
    }

    breakpoint.COUNT_FILTER_ENABLED = breakpoint.COUNT_FILTER > 0 && myPassCountCheckbox.isSelected();
    breakpoint.setCondition(myConditionCombo.getText());
    breakpoint.CONDITION_ENABLED = myConditionCheckbox.isSelected();
    breakpoint.setLogMessage(myLogExpressionCombo.getText());
    breakpoint.LOG_EXPRESSION_ENABLED = !breakpoint.getLogMessage().isEmpty() && myLogExpressionCheckBox.isSelected();
    breakpoint.LOG_ENABLED = myLogMessageCheckBox.isSelected();
    breakpoint.ENABLED = myEnabledCheckbox.isSelected();
    breakpoint.REMOVE_AFTER_HIT = myTemporaryCheckBox.isSelected();
    breakpoint.SUSPEND = myCbSuspend.isSelected();
    breakpoint.SUSPEND_POLICY = getSelectedSuspendPolicy();
    reloadInstanceFilters();
    reloadClassFilters();
    updateInstanceFilterEditor(true);
    updateClassFilterEditor(true);

    breakpoint.INSTANCE_FILTERS_ENABLED = myInstanceFiltersField.getText().length() > 0 && myInstanceFiltersCheckBox.isSelected();
    breakpoint.CLASS_FILTERS_ENABLED = myClassFiltersField.getText().length() > 0 && myClassFiltersCheckBox.isSelected();
    breakpoint.setClassFilters(myClassFilters);
    breakpoint.setClassExclusionFilters(myClassExclusionFilters);
    breakpoint.setInstanceFilters(myInstanceFilters);

    myConditionCombo.addRecent(myConditionCombo.getText());
    myLogExpressionCombo.addRecent(myLogExpressionCombo.getText());
    breakpoint.updateUI(afterUpdate);
  }

  private static String concatWithEx(List<String> s, String concator, int N, String NthConcator) {
    String result = "";
    int i = 1;
    for (Iterator iterator = s.iterator(); iterator.hasNext(); i++) {
      String str = (String) iterator.next();
      result += str;
      if(iterator.hasNext()){
        if(i % N == 0){
          result += NthConcator;
        }
        else {
          result += concator;
        }
      }
    }
    return result;
  }

  private void updateInstanceFilterEditor(boolean updateText) {
    List<String> filters = new ArrayList<String>();
    for (InstanceFilter instanceFilter : myInstanceFilters) {
      if (instanceFilter.isEnabled()) {
        filters.add(Long.toString(instanceFilter.getId()));
      }
    }
    if (updateText) {
      myInstanceFiltersField.setText(StringUtil.join(filters, " "));
    }

    String tipText = concatWithEx(filters, " ", (int)Math.sqrt(myInstanceFilters.length) + 1, "\n");
    myInstanceFiltersField.getTextField().setToolTipText(tipText);
  }

  private void reloadInstanceFilters() {
    String filtersText = myInstanceFiltersField.getText();

    ArrayList<InstanceFilter> idxs = new ArrayList<InstanceFilter>();
    int startNumber = -1;
    for(int i = 0; i <= filtersText.length(); i++) {
      if(i < filtersText.length() && Character.isDigit(filtersText.charAt(i))) {
        if(startNumber == -1) {
          startNumber = i;
        }
      }
      else {
        if(startNumber >=0) {
          idxs.add(InstanceFilter.create(filtersText.substring(startNumber, i)));
          startNumber = -1;
        }
      }
    }
    for (InstanceFilter instanceFilter : myInstanceFilters) {
      if (!instanceFilter.isEnabled()) {
        idxs.add(instanceFilter);
      }
    }
    myInstanceFilters = idxs.toArray(new InstanceFilter[idxs.size()]);
  }

  private void updateClassFilterEditor(boolean updateText) {
    List<String> filters = new ArrayList<String>();
    for (com.intellij.ui.classFilter.ClassFilter classFilter : myClassFilters) {
      if (classFilter.isEnabled()) {
        filters.add(classFilter.getPattern());
      }
    }
    List<String> excludeFilters = new ArrayList<String>();
    for (com.intellij.ui.classFilter.ClassFilter classFilter : myClassExclusionFilters) {
      if (classFilter.isEnabled()) {
        excludeFilters.add("-" + classFilter.getPattern());
      }
    }
    if (updateText) {
      String editorText = StringUtil.join(filters, " ");
      if(!filters.isEmpty()) {
        editorText += " ";
      }
      editorText += StringUtil.join(excludeFilters, " ");
      myClassFiltersField.setText(editorText);
    }

    int width = (int)Math.sqrt(myClassExclusionFilters.length + myClassFilters.length) + 1;
    String tipText = concatWithEx(filters, " ", width, "\n");
    if(!filters.isEmpty()) {
      tipText += "\n";
    }
    tipText += concatWithEx(excludeFilters, " ", width, "\n");
    myClassFiltersField.getTextField().setToolTipText(tipText);
  }

  private void reloadClassFilters() {
    String filtersText = myClassFiltersField.getText();

    ArrayList<com.intellij.ui.classFilter.ClassFilter> classFilters     = new ArrayList<com.intellij.ui.classFilter.ClassFilter>();
    ArrayList<com.intellij.ui.classFilter.ClassFilter> exclusionFilters = new ArrayList<com.intellij.ui.classFilter.ClassFilter>();
    int startFilter = -1;
    for(int i = 0; i <= filtersText.length(); i++) {
      if(i < filtersText.length() && !Character.isWhitespace(filtersText.charAt(i))){
        if(startFilter == -1) {
          startFilter = i;
        }
      }
      else {
        if(startFilter >=0) {
          if(filtersText.charAt(startFilter) == '-') {
            exclusionFilters.add(new com.intellij.ui.classFilter.ClassFilter(filtersText.substring(startFilter + 1, i)));
          }
          else {
            classFilters.add(new com.intellij.ui.classFilter.ClassFilter(filtersText.substring(startFilter, i)));
          }
          startFilter = -1;
        }
      }
    }
    for (com.intellij.ui.classFilter.ClassFilter classFilter : myClassFilters) {
      if (!classFilter.isEnabled()) {
        classFilters.add(classFilter);
      }
    }
    for (com.intellij.ui.classFilter.ClassFilter classFilter : myClassExclusionFilters) {
      if (!classFilter.isEnabled()) {
        exclusionFilters.add(classFilter);
      }
    }
    myClassFilters          = classFilters    .toArray(new com.intellij.ui.classFilter.ClassFilter[classFilters    .size()]);
    myClassExclusionFilters = exclusionFilters.toArray(new com.intellij.ui.classFilter.ClassFilter[exclusionFilters.size()]);
  }

  public void setEnabled(boolean enabled) {
    myPanel.setEnabled(enabled);
    Component[] components = myPanel.getComponents();
    for (Component component : components) {
      component.setEnabled(enabled);
    }
  }

  protected void updateCheckboxes() {
    boolean passCountApplicable = true;
    if (myInstanceFiltersCheckBox.isSelected() || myClassFiltersCheckBox.isSelected()) {
      passCountApplicable = false;
    }
    myPassCountCheckbox.setEnabled(passCountApplicable);

    final boolean passCountSelected = myPassCountCheckbox.isSelected();
    myInstanceFiltersCheckBox.setEnabled(!passCountSelected);
    myClassFiltersCheckBox.setEnabled(!passCountSelected);

    myPassCountField.setEditable(myPassCountCheckbox.isSelected());
    myPassCountField.setEnabled (myPassCountCheckbox.isSelected());

    myConditionCombo.setEnabled(myConditionCheckbox.isSelected());
    myConditionMagnifierButton.setEnabled(myConditionCheckbox.isSelected());

    myInstanceFiltersField.setEnabled(myInstanceFiltersCheckBox.isSelected());
    myInstanceFiltersField.getTextField().setEditable(myInstanceFiltersCheckBox.isSelected());

    myClassFiltersField.setEnabled(myClassFiltersCheckBox.isSelected());
    myClassFiltersField.getTextField().setEditable(myClassFiltersCheckBox.isSelected());
  }

  public JPanel getPanel() {
    return myPanel;
  }

  private static BreakpointManager getBreakpointManager(Project project) {
    return DebuggerManagerEx.getInstanceEx(project).getBreakpointManager();
  }

  private static class MagnifierButtonAction implements ActionListener {
    private final Project myProject;
    private final CompletionEditor myTargetEditor;
    private final String myDialogTitle;
    private DebuggerStatementEditor myEditor;

    private MagnifierButtonAction(final Project project, final CompletionEditor targetEditor, final String dialogTitle) {
      myProject = project;
      myTargetEditor = targetEditor;
      myDialogTitle = dialogTitle;
    }

    @Override
    public void actionPerformed(final ActionEvent e) {
      new DialogWrapper(myTargetEditor, true){
        @Override
        public void show() {
          setTitle(myDialogTitle);
          setModal(true);
          init();
          super.show();
        }

        @Override
        public JComponent getPreferredFocusedComponent() {
          return myEditor;
        }

        @Override
        @Nullable
        protected JComponent createCenterPanel() {
          final JPanel panel = new JPanel(new BorderLayout());
          myEditor = new DebuggerStatementEditor(myProject, myTargetEditor.getContext(), myTargetEditor.getRecentsId(), DefaultCodeFragmentFactory.getInstance());
          myEditor.setPreferredSize(new Dimension(400, 150));
          myEditor.setText(myTargetEditor.getText());
          panel.add(myEditor, BorderLayout.CENTER);
          return panel;
        }

        @Override
        protected void doOKAction() {
          myTargetEditor.setText(myEditor.getText());
          super.doOKAction();
        }
      }.show();
    }
  }
}