/*
 * Copyright 2000-2010 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.openapi.diff.impl.util;

import com.intellij.openapi.diff.DiffBundle;
import com.intellij.openapi.diff.DiffColors;
import com.intellij.openapi.diff.ex.DiffStatusBar;
import com.intellij.openapi.editor.Editor;
import com.intellij.openapi.editor.colors.EditorColorsScheme;
import com.intellij.openapi.editor.colors.TextAttributesKey;
import com.intellij.openapi.editor.ex.EditorEx;
import com.intellij.openapi.editor.markup.TextAttributes;
import com.intellij.util.containers.Convertor;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;

import java.awt.*;
import java.util.Arrays;
import java.util.List;

public class TextDiffType implements DiffStatusBar.LegendTypeDescriptor {
  public static final TextDiffType INSERT = new TextDiffType(TextDiffTypeEnum.INSERT, DiffBundle.message("diff.type.inserted.name"), DiffColors.DIFF_INSERTED);
  public static final TextDiffType CHANGED = new TextDiffType(TextDiffTypeEnum.CHANGED, DiffBundle.message("diff.type.changed.name"), DiffColors.DIFF_MODIFIED);
  public static final TextDiffType DELETED = new TextDiffType(TextDiffTypeEnum.DELETED, DiffBundle.message("diff.type.deleted.name"), DiffColors.DIFF_DELETED);
  public static final TextDiffType CONFLICT = new TextDiffType(TextDiffTypeEnum.CONFLICT, DiffBundle.message("diff.type.conflict.name"), DiffColors.DIFF_CONFLICT);

  public static final TextDiffType NONE = new TextDiffType(TextDiffTypeEnum.NONE, DiffBundle.message("diff.type.none.name"), null);

  public static final List<TextDiffType> DIFF_TYPES = Arrays.asList(DELETED, CHANGED, INSERT);
  public static final List<TextDiffType> MERGE_TYPES = Arrays.asList(DELETED, CHANGED, INSERT, CONFLICT);

  public static final Convertor<TextDiffType, TextAttributesKey> ATTRIBUTES_KEY = new Convertor<TextDiffType, TextAttributesKey>() {
    public TextAttributesKey convert(TextDiffType textDiffType) {
      return textDiffType.getAttributesKey();
    }
  };
  private static final double MIDDLE_COLOR_FACTOR = 0.6;

  private final TextDiffTypeEnum myType;
  private final TextAttributesKey myAttributesKey;
  private final String myDisplayName;
  private final boolean myApplied;
  private final boolean myInlineWrapper;

  public boolean isApplied() {
    return myApplied;
  }

  public boolean isInlineWrapper() {
    return myInlineWrapper;
  }

  @NotNull
  public static TextDiffType create(@Nullable final TextDiffTypeEnum type) {
    if (TextDiffTypeEnum.INSERT.equals(type)) {
      return INSERT;
    } else if (TextDiffTypeEnum.CHANGED.equals(type)) {
      return CHANGED;
    } else if (TextDiffTypeEnum.DELETED.equals(type)) {
      return DELETED;
    } else if (TextDiffTypeEnum.CONFLICT.equals(type)) {
      return CONFLICT;
    } else {
      return NONE;
    }
  }

  /**
   * Creates a new TextDiffType based on the given one.
   * @param source
   * @return
   */
  @NotNull
  public static TextDiffType deriveApplied(@NotNull TextDiffType source) {
    return new TextDiffType(source.myType, source.myDisplayName, source.myAttributesKey, true, false);
  }

  public static TextDiffType deriveInstanceForInlineWrapperFragment(@NotNull TextDiffType source) {
    return new TextDiffType(source.myType, source.myDisplayName, source.myAttributesKey, source.myApplied, true);
  }

  private TextDiffType(TextDiffTypeEnum type, String displayName, TextAttributesKey attributesKey) {
    this(type, displayName, attributesKey, false, false);
  }

  private TextDiffType(TextDiffTypeEnum type, String displayName, TextAttributesKey attributesKey, boolean applied,
                       boolean inlineWrapper) {
    myType = type;
    myAttributesKey = attributesKey;
    myDisplayName = displayName;
    myApplied = applied;
    myInlineWrapper = inlineWrapper;
  }

  public String getDisplayName() {
    return myDisplayName;
  }

  @Nullable
  public Color getLegendColor(EditorColorsScheme colorScheme) {
    TextAttributes attributes = colorScheme.getAttributes(myAttributesKey);
    return attributes != null ? attributes.getBackgroundColor() : null;
  }

  public TextAttributesKey getAttributesKey() {
    return myAttributesKey;
  }

  @Nullable
  public TextAttributes getTextAttributes(@NotNull EditorColorsScheme scheme) {
    return scheme.getAttributes(myAttributesKey);
  }

  @Nullable
  public Color getPolygonColor(Editor editor) {
    if (isApplied()) {
      return getLegendColor(editor.getColorsScheme());
    }
    else if (isInlineWrapper()) {
      return getBgColorForFragmentContainingInlines((EditorEx)editor);
    }
    else {
      TextAttributes attributes = getTextAttributes(editor);
      return attributes == null ? null : attributes.getBackgroundColor();
    }
  }

  @Nullable
  public TextAttributes getTextAttributes(@NotNull Editor editor) {
    TextAttributes originalAttrs = getTextAttributes(editor.getColorsScheme());
    if (originalAttrs == null) {
      return null;
    }
    TextAttributes overridingAttributes = new TextAttributes();
    if (myApplied) {
      overridingAttributes.setBackgroundColor(((EditorEx)editor).getBackgroundColor());
    }
    else if (myInlineWrapper) {
      overridingAttributes.setBackgroundColor(getBgColorForFragmentContainingInlines((EditorEx)editor));
    }
    return TextAttributes.merge(originalAttrs, overridingAttributes);
  }

  @Nullable
  public Color getTextBackground(Editor editor) {
    TextAttributes attributes = getTextAttributes(editor);
    return attributes != null ? attributes.getBackgroundColor() : null;
  }

  public String toString(){
    return myApplied ? myDisplayName + "_applied" : myDisplayName;
  }

  public TextDiffTypeEnum getType() {
    return myType;
  }

  @Nullable
  private Color getBgColorForFragmentContainingInlines(@NotNull EditorEx editor) {
    TextAttributes originalAttrs = getTextAttributes(editor.getColorsScheme());
    if (originalAttrs == null) {
      return null;
    }
    Color fg = originalAttrs.getBackgroundColor();
    if (fg == null) {
      return null;
    }
    Color bg = editor.getBackgroundColor();
    return getMiddleColor(fg, bg, MIDDLE_COLOR_FACTOR);
  }

  @NotNull
  private static Color getMiddleColor(Color fg, Color bg, double factor) {
    int red = avg(fg.getRed(), bg.getRed(), factor);
    int green = avg(fg.getGreen(), bg.getGreen(), factor);
    int blue = avg(fg.getBlue(), bg.getBlue(), factor);
    return new Color(red, green, blue);
  }

  private static int avg(int fg, int bg, double factor) {
      return (int)(fg + Math.round(factor * (bg - fg)));
  }

}