/*

 * Copyright (c) 2011, Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

package com.apple.laf;

import java.awt.*;

import java.awt.event.*;

import java.awt.geom.AffineTransform;

import java.beans.*;

import javax.swing.*;

import javax.swing.event.*;

import javax.swing.plaf.*;

import javax.swing.text.View;

import sun.swing.SwingUtilities2;

import apple.laf.*;

import apple.laf.JRSUIConstants.*;

public class AquaTabbedPaneUI extends AquaTabbedPaneCopyFromBasicUI {

    private static final int kSmallTabHeight = 20; // height of a small tab

    private static final int kLargeTabHeight = 23; // height of a large tab

    private static final int kMaxIconSize = kLargeTabHeight - 7;

    private static final double kNinetyDegrees = (Math.PI / 2.0); // used for rotation

    protected final Insets currentContentDrawingInsets = new Insets(0, 0, 0, 0);

    protected final Insets currentContentBorderInsets = new Insets(0, 0, 0, 0);

    protected final Insets contentDrawingInsets = new Insets(0, 0, 0, 0);

    protected int pressedTab = -3; // -2 is right scroller, -1 is left scroller

    protected boolean popupSelectionChanged;

    protected Boolean isDefaultFocusReceiver = null;

    protected boolean hasAvoidedFirstFocus = false;

    // Create PLAF

    public static ComponentUI createUI(final JComponent c) {

        return new AquaTabbedPaneUI();

    }

    protected final AquaTabbedPaneTabState visibleTabState = new AquaTabbedPaneTabState(this);

    protected final AquaPainter<JRSUIState> painter = AquaPainter.create(JRSUIStateFactory.getTab());

    public AquaTabbedPaneUI() { }

    protected void installListeners() {

        super.installListeners();

        // We're not just a mouseListener, we're a mouseMotionListener

        if (mouseListener != null) {

            tabPane.addMouseMotionListener((MouseMotionListener)mouseListener);

        }

    }

    protected void installDefaults() {

        super.installDefaults();

        if (tabPane.getFont() instanceof UIResource) {

            final Boolean b = (Boolean)UIManager.get("TabbedPane.useSmallLayout");

            if (b != null && b == Boolean.TRUE) {

                tabPane.setFont(UIManager.getFont("TabbedPane.smallFont"));

                painter.state.set(Size.SMALL);

            }

        }

        contentDrawingInsets.set(0, 11, 13, 10);

        tabPane.setOpaque(false);

    }

    protected void assureRectsCreated(final int tabCount) {

        visibleTabState.init(tabCount);

        super.assureRectsCreated(tabCount);

    }

    protected void uninstallDefaults() {

        contentDrawingInsets.set(0, 0, 0, 0);

    }

    protected MouseListener createMouseListener() {

        return new MouseHandler();

    }

    protected FocusListener createFocusListener() {

        return new FocusHandler();

    }

    protected PropertyChangeListener createPropertyChangeListener() {

        return new TabbedPanePropertyChangeHandler();

    }

    protected LayoutManager createLayoutManager() {

        return new AquaTruncatingTabbedPaneLayout();

    }

    protected boolean shouldRepaintSelectedTabOnMouseDown() {

        return false;

    }

    // Paint Methods

    // Cache for performance

    final Rectangle fContentRect = new Rectangle();

    final Rectangle fIconRect = new Rectangle();

    final Rectangle fTextRect = new Rectangle();

    // UI Rendering

    public void paint(final Graphics g, final JComponent c) {

        painter.state.set(getDirection());

        final int tabPlacement = tabPane.getTabPlacement();

        final int selectedIndex = tabPane.getSelectedIndex();

        paintContentBorder(g, tabPlacement, selectedIndex);

        // we want to call ensureCurrentLayout, but it's private

        ensureCurrentLayout();

        final Rectangle clipRect = g.getClipBounds();

        final boolean active = tabPane.isEnabled();

        final boolean frameActive = AquaFocusHandler.isActive(tabPane);

        final boolean isLeftToRight = tabPane.getComponentOrientation().isLeftToRight() || tabPlacement == LEFT || tabPlacement == RIGHT;

        // Paint tabRuns of tabs from back to front

        if (visibleTabState.needsScrollTabs()) {

            paintScrollingTabs(g, clipRect, tabPlacement, selectedIndex, active, frameActive, isLeftToRight);

            return;

        }

        // old way

        paintAllTabs(g, clipRect, tabPlacement, selectedIndex, active, frameActive, isLeftToRight);

    }

    protected void paintAllTabs(final Graphics g, final Rectangle clipRect, final int tabPlacement, final int selectedIndex, final boolean active, final boolean frameActive, final boolean isLeftToRight) {

        boolean drawSelectedLast = false;

        for (int i = 0; i < rects.length; i++) {

            if (i == selectedIndex) {

                drawSelectedLast = true;

            } else {

                if (rects[i].intersects(clipRect)) {

                    paintTabNormal(g, tabPlacement, i, active, frameActive, isLeftToRight);

                }

            }

        }

        // paint the selected tab last.

        if (drawSelectedLast && rects[selectedIndex].intersects(clipRect)) {

            paintTabNormal(g, tabPlacement, selectedIndex, active, frameActive, isLeftToRight);

        }

    }

    protected void paintScrollingTabs(final Graphics g, final Rectangle clipRect, final int tabPlacement, final int selectedIndex, final boolean active, final boolean frameActive, final boolean isLeftToRight) {

//        final Graphics g2 = g.create();

//        g2.setColor(Color.cyan);

//        Rectangle r = new Rectangle();

//        for (int i = 0; i < visibleTabState.getTotal(); i++) {

//            r.add(rects[visibleTabState.getIndex(i)]);

//        }

//        g2.fillRect(r.x, r.y, r.width, r.height);

//        g2.dispose();

//        System.out.println(r);

        // for each visible tab, except the selected one

        for (int i = 0; i < visibleTabState.getTotal(); i++) {

            final int realIndex = visibleTabState.getIndex(i);

            if (realIndex != selectedIndex) {

                if (rects[realIndex].intersects(clipRect)) {

                    paintTabNormal(g, tabPlacement, realIndex, active, frameActive, isLeftToRight);

                }

            }

        }

        final Rectangle leftScrollTabRect = visibleTabState.getLeftScrollTabRect();

        if (visibleTabState.needsLeftScrollTab() && leftScrollTabRect.intersects(clipRect)) {

            paintTabNormalFromRect(g, tabPlacement, leftScrollTabRect, -2, fIconRect, fTextRect, visibleTabState.needsLeftScrollTab(), frameActive, isLeftToRight);

        }

        final Rectangle rightScrollTabRect = visibleTabState.getRightScrollTabRect();

        if (visibleTabState.needsRightScrollTab() && rightScrollTabRect.intersects(clipRect)) {

            paintTabNormalFromRect(g, tabPlacement, rightScrollTabRect, -1, fIconRect, fTextRect, visibleTabState.needsRightScrollTab(), frameActive, isLeftToRight);

        }

        if (selectedIndex >= 0) { // && rects[selectedIndex].intersects(clipRect)) {

            paintTabNormal(g, tabPlacement, selectedIndex, active, frameActive, isLeftToRight);

        }

    }

    private static boolean isScrollTabIndex(final int index) {

        return index == -1 || index == -2;

    }

    protected static void transposeRect(final Rectangle r) {

        int temp = r.y;

        r.y = r.x;

        r.x = temp;

        temp = r.width;

        r.width = r.height;

        r.height = temp;

    }

    protected int getTabLabelShiftX(final int tabPlacement, final int tabIndex, final boolean isSelected) {

        final Rectangle tabRect = (tabIndex >= 0 ? rects[tabIndex] : visibleTabState.getRightScrollTabRect());

        int nudge = 0;

        switch (tabPlacement) {

            case LEFT:

            case RIGHT:

                nudge = tabRect.height % 2;

                break;

            case BOTTOM:

            case TOP:

            default:

                nudge = tabRect.width % 2;

        }

        return nudge;

    }

    protected int getTabLabelShiftY(final int tabPlacement, final int tabIndex, final boolean isSelected) {

        switch (tabPlacement) {

            case RIGHT:

            case LEFT:

            case BOTTOM:

                return -1;

            case TOP:

            default:

                return 0;

        }

    }

    protected Icon getIconForScrollTab(final int tabPlacement, final int tabIndex, final boolean enabled) {

        boolean shouldFlip = !AquaUtils.isLeftToRight(tabPane);

        if (tabPlacement == RIGHT) shouldFlip = false;

        if (tabPlacement == LEFT) shouldFlip = true;

        int direction = tabIndex == -1 ? EAST : WEST;

        if (shouldFlip) {

            if (direction == EAST) {

                direction = WEST;

            } else if (direction == WEST) {

                direction = EAST;

            }

        }

        if (enabled) return AquaImageFactory.getArrowIconForDirection(direction);

        final Image icon = AquaImageFactory.getArrowImageForDirection(direction);

        return new ImageIcon(AquaUtils.generateDisabledImage(icon));

    }

    protected void paintContents(final Graphics g, final int tabPlacement, final int tabIndex, final Rectangle tabRect, final Rectangle iconRect, final Rectangle textRect, final boolean isSelected) {

        final Shape temp = g.getClip();

        g.clipRect(fContentRect.x, fContentRect.y, fContentRect.width, fContentRect.height);

        final Component component;

        final String title;

        final Icon icon;

        if (isScrollTabIndex(tabIndex)) {

            component = null;

            title = null;

            icon = getIconForScrollTab(tabPlacement, tabIndex, true);

        } else {

            component = getTabComponentAt(tabIndex);

            if (component == null) {

                title = tabPane.getTitleAt(tabIndex);

                icon = getIconForTab(tabIndex);

            } else {

                title = null;

                icon = null;

            }

        }

        final boolean isVertical = tabPlacement == RIGHT || tabPlacement == LEFT;

        if (isVertical) {

            transposeRect(fContentRect);

        }

        final Font font = tabPane.getFont();

        final FontMetrics metrics = g.getFontMetrics(font);

        // our scrolling tabs

        layoutLabel(tabPlacement, metrics, tabIndex < 0 ? 0 : tabIndex, title, icon, fContentRect, iconRect, textRect, false); // Never give it "isSelected" - ApprMgr handles this

        if (isVertical) {

            transposeRect(fContentRect);

            transposeRect(iconRect);

            transposeRect(textRect);

        }

        // from super.paintText - its normal text painting is totally wrong for the Mac

        if (!(g instanceof Graphics2D)) {

            g.setClip(temp);

            return;

        }

        final Graphics2D g2d = (Graphics2D) g;

        AffineTransform savedAT = null;

        if (isVertical) {

            savedAT = g2d.getTransform();

            rotateGraphics(g2d, tabRect, textRect, iconRect, tabPlacement);

        }

        // not for the scrolling tabs

        if (component == null && tabIndex >= 0) {

            paintTitle(g2d, font, metrics, textRect, tabIndex, title);

        }

        if (icon != null) {

            paintIcon(g, tabPlacement, tabIndex, icon, iconRect, isSelected);

        }

        if (savedAT != null) {

            g2d.setTransform(savedAT);

        }

        g.setClip(temp);

    }

    protected void paintTitle(final Graphics2D g2d, final Font font, final FontMetrics metrics, final Rectangle textRect, final int tabIndex, final String title) {

        final View v = getTextViewForTab(tabIndex);

        if (v != null) {

            v.paint(g2d, textRect);

            return;

        }

        if (title == null) return;

        final Color color = tabPane.getForegroundAt(tabIndex);

        if (color instanceof UIResource) {

            // sja fix getTheme().setThemeTextColor(g, isSelected, isPressed && tracking, tabPane.isEnabledAt(tabIndex));

            if (tabPane.isEnabledAt(tabIndex)) {

                g2d.setColor(Color.black);

            } else {

                g2d.setColor(Color.gray);

            }

        } else {

            g2d.setColor(color);

        }

        g2d.setFont(font);

        SwingUtilities2.drawString(tabPane, g2d, title, textRect.x, textRect.y + metrics.getAscent());

    }

    protected void rotateGraphics(final Graphics2D g2d, final Rectangle tabRect, final Rectangle textRect, final Rectangle iconRect, final int tabPlacement) {

        int yDiff = 0; // textRect.y - tabRect.y;

        int xDiff = 0; // (tabRect.x+tabRect.width) - (textRect.x+textRect.width);

        int yIconDiff = 0; // iconRect.y - tabRect.y;

        int xIconDiff = 0; // (tabRect.x+tabRect.width) - (iconRect.x + iconRect.width);

        final double rotateAmount = (tabPlacement == LEFT ? -kNinetyDegrees : kNinetyDegrees);

        g2d.transform(AffineTransform.getRotateInstance(rotateAmount, tabRect.x, tabRect.y));

        // x and y diffs are named weirdly.

        // I will rename them, but what they mean now is

        // original x offset which will be used to adjust the y coordinate for the

        // rotated context

        if (tabPlacement == LEFT) {

            g2d.translate(-tabRect.height - 1, 1);

            xDiff = textRect.x - tabRect.x;

            yDiff = tabRect.height + tabRect.y - (textRect.y + textRect.height);

            xIconDiff = iconRect.x - tabRect.x;

            yIconDiff = tabRect.height + tabRect.y - (iconRect.y + iconRect.height);

        } else {

            g2d.translate(0, -tabRect.width - 1);

            yDiff = textRect.y - tabRect.y;

            xDiff = (tabRect.x + tabRect.width) - (textRect.x + textRect.width);

            yIconDiff = iconRect.y - tabRect.y;

            xIconDiff = (tabRect.x + tabRect.width) - (iconRect.x + iconRect.width);

        }

        // rotation changes needed for the rendering

        // we are rotating so we can't just use the rects wholesale.

        textRect.x = tabRect.x + yDiff;

        textRect.y = tabRect.y + xDiff;

        int tempVal = textRect.height;

        textRect.height = textRect.width;

        textRect.width = tempVal;

    // g.setColor(Color.red);

    // g.drawLine(textRect.x, textRect.y, textRect.x+textRect.height, textRect.y+textRect.width);

    // g.drawLine(textRect.x+textRect.height, textRect.y, textRect.x, textRect.y+textRect.width);

        iconRect.x = tabRect.x + yIconDiff;

        iconRect.y = tabRect.y + xIconDiff;

        tempVal = iconRect.height;

        iconRect.height = iconRect.width;

        iconRect.width = tempVal;

    }

    protected void paintTabNormal(final Graphics g, final int tabPlacement, final int tabIndex, final boolean active, final boolean frameActive, final boolean isLeftToRight) {

        paintTabNormalFromRect(g, tabPlacement, rects[tabIndex], tabIndex, fIconRect, fTextRect, active, frameActive, isLeftToRight);

    }

    protected void paintTabNormalFromRect(final Graphics g, final int tabPlacement, final Rectangle tabRect, final int nonRectIndex, final Rectangle iconRect, final Rectangle textRect, final boolean active, final boolean frameActive, final boolean isLeftToRight) {

        final int selectedIndex = tabPane.getSelectedIndex();

        final boolean isSelected = selectedIndex == nonRectIndex;

        paintCUITab(g, tabPlacement, tabRect, isSelected, frameActive, isLeftToRight, nonRectIndex);

        textRect.setBounds(tabRect);

        fContentRect.setBounds(tabRect);

        paintContents(g, tabPlacement, nonRectIndex, tabRect, iconRect, textRect, isSelected);

    }

    protected void paintCUITab(final Graphics g, final int tabPlacement, final Rectangle tabRect, final boolean isSelected, final boolean frameActive, final boolean isLeftToRight, final int nonRectIndex) {

        final int tabCount = tabPane.getTabCount();

        final boolean needsLeftScrollTab = visibleTabState.needsLeftScrollTab();

        final boolean needsRightScrollTab = visibleTabState.needsRightScrollTab();

        // first or last

        boolean first = nonRectIndex == 0;

        boolean last = nonRectIndex == tabCount - 1;

        if (needsLeftScrollTab || needsRightScrollTab) {

            if (nonRectIndex == -1) {

                first = false;

                last = true;

            } else if (nonRectIndex == -2) {

                first = true;

                last = false;

            } else {

                if (needsLeftScrollTab) first = false;

                if (needsRightScrollTab) last = false;

            }

        }

        if (tabPlacement == LEFT || tabPlacement == RIGHT) {

            final boolean tempSwap = last;

            last = first;

            first = tempSwap;

        }

        final State state = getState(nonRectIndex, frameActive, isSelected);

        painter.state.set(state);

        painter.state.set(isSelected || (state == State.INACTIVE && frameActive) ? BooleanValue.YES : BooleanValue.NO);

        painter.state.set(getSegmentPosition(first, last, isLeftToRight));

        final int selectedIndex = tabPane.getSelectedIndex();

        painter.state.set(getSegmentTrailingSeparator(nonRectIndex, selectedIndex, isLeftToRight));

        painter.state.set(getSegmentLeadingSeparator(nonRectIndex, selectedIndex, isLeftToRight));

        painter.state.set(tabPane.hasFocus() && isSelected ? Focused.YES : Focused.NO);

        painter.paint(g, tabPane, tabRect.x, tabRect.y, tabRect.width, tabRect.height);

        if (isScrollTabIndex(nonRectIndex)) return;

        final Color color = tabPane.getBackgroundAt(nonRectIndex);

        if (color == null || (color instanceof UIResource)) return;

        if (!isLeftToRight && (tabPlacement == TOP || tabPlacement == BOTTOM)) {

            final boolean tempSwap = last;

            last = first;

            first = tempSwap;

        }

        fillTabWithBackground(g, tabRect, tabPlacement, first, last, color);

    }

    protected Direction getDirection() {

        switch (tabPane.getTabPlacement()) {

            case SwingConstants.BOTTOM: return Direction.SOUTH;

            case SwingConstants.LEFT: return Direction.WEST;

            case SwingConstants.RIGHT: return Direction.EAST;

        }

        return Direction.NORTH;

    }

    protected static SegmentPosition getSegmentPosition(final boolean first, final boolean last, final boolean isLeftToRight) {

        if (first && last) return SegmentPosition.ONLY;

        if (first) return isLeftToRight ? SegmentPosition.FIRST : SegmentPosition.LAST;

        if (last) return isLeftToRight ? SegmentPosition.LAST : SegmentPosition.FIRST;

        return SegmentPosition.MIDDLE;

    }

    protected SegmentTrailingSeparator getSegmentTrailingSeparator(final int index, final int selectedIndex, final boolean isLeftToRight) {

        return SegmentTrailingSeparator.YES;

    }

    protected SegmentLeadingSeparator getSegmentLeadingSeparator(final int index, final int selectedIndex, final boolean isLeftToRight) {

        return SegmentLeadingSeparator.NO;

    }

    protected boolean isTabBeforeSelectedTab(final int index, final int selectedIndex, final boolean isLeftToRight) {

        if (index == -2 && visibleTabState.getIndex(0) == selectedIndex) return true;

        int indexBeforeSelectedIndex = isLeftToRight ? selectedIndex - 1 : selectedIndex + 1;

        return index == indexBeforeSelectedIndex ? true : false;

    }

    protected State getState(final int index, final boolean frameActive, final boolean isSelected) {

        if (!frameActive) return State.INACTIVE;

        if (!tabPane.isEnabled()) return State.DISABLED;

        if (JRSUIUtils.TabbedPane.useLegacyTabs()) {

            if (isSelected) return State.PRESSED;

            if (pressedTab == index) return State.INACTIVE;

        } else {

            if (isSelected) return State.ACTIVE;

            if (pressedTab == index) return State.PRESSED;

        }

        return State.ACTIVE;

    }

    /**

     * This routine adjusts the background fill rect so it just fits inside a tab, allowing for

     * whether we're talking about a first tab or last tab.  NOTE that this code is very much

     * Aqua 2 dependent!

     */

    static class AlterRects {

        Rectangle standard, first, last;

        AlterRects(final int x, final int y, final int w, final int h) { standard = new Rectangle(x, y, w, h); }

        AlterRects start(final int x, final int y, final int w, final int h) { first = new Rectangle(x, y, w, h); return this; }

        AlterRects end(final int x, final int y, final int w, final int h) { last = new Rectangle(x, y, w, h); return this; }