/*****************************************************************************
 * Copyright (c) 2018, 2020 Dirk Fauth.
 *
 * This program and the accompanying materials are made
 * available under the terms of the Eclipse Public License 2.0
 * which is available at https://www.eclipse.org/legal/epl-2.0/
 *
 * SPDX-License-Identifier: EPL-2.0
 *
 * Contributors:
 *      Dirk Fauth <dirk.fauth@googlemail.com> - Initial API and implementation
 *****************************************************************************/
package org.eclipse.nebula.widgets.nattable.hideshow.indicator;

import org.eclipse.nebula.widgets.nattable.hierarchical.HierarchicalTreeLayer;
import org.eclipse.nebula.widgets.nattable.layer.ILayer;
import org.eclipse.nebula.widgets.nattable.layer.LabelStack;
import org.eclipse.nebula.widgets.nattable.layer.LayerUtil;
import org.eclipse.nebula.widgets.nattable.layer.cell.ILayerCell;
import org.eclipse.swt.graphics.GC;
import org.eclipse.swt.graphics.Rectangle;

/**
 * Specialization of the {@link HideIndicatorOverlayPainter} that renders the
 * hide indicator in the level header columns of a
 * {@link HierarchicalTreeLayer}. The identification of the level header columns
 * is done via the cell label {@link HierarchicalTreeLayer#LEVEL_HEADER_CELL}.
 *
 * @since 1.6
 */
public class HierarchicalHideIndicatorOverlayPainter extends HideIndicatorOverlayPainter {

    protected HierarchicalTreeLayer treeLayer;

    /**
     * Creates a {@link HierarchicalHideIndicatorOverlayPainter} that renders
     * the hide indicator in the given given column header layer and the
     * {@link HierarchicalTreeLayer} level header columns.
     *
     * @param columnHeaderLayer
     *            The layer in the column header that should be used to
     *            determine the height of the hidden column indicator. Should be
     *            the top most layer in the column header region, e.g. the
     *            FilterRowHeaderComposite in case filtering is included. Can be
     *            <code>null</code> to avoid rendering of hidden column
     *            indicators.
     */
    public HierarchicalHideIndicatorOverlayPainter(ILayer columnHeaderLayer, HierarchicalTreeLayer treeLayer) {
        this(columnHeaderLayer, null, treeLayer);
    }

    /**
     * Creates a {@link HierarchicalHideIndicatorOverlayPainter} that renders
     * the hide indicator in the given header layers and the
     * {@link HierarchicalTreeLayer} level header columns.
     *
     * @param columnHeaderLayer
     *            The layer in the column header that should be used to
     *            determine the height of the hidden column indicator. Should be
     *            the top most layer in the column header region, e.g. the
     *            FilterRowHeaderComposite in case filtering is included. Can be
     *            <code>null</code> to avoid rendering of hidden column
     *            indicators.
     * @param rowHeaderLayer
     *            The layer in the row header that should be used to determine
     *            the width of the hidden row indicator. Should be the top most
     *            layer in the row header region. Can be <code>null</code> to
     *            avoid rendering of hidden row indicators.
     */
    public HierarchicalHideIndicatorOverlayPainter(ILayer columnHeaderLayer, ILayer rowHeaderLayer, HierarchicalTreeLayer treeLayer) {
        super(columnHeaderLayer, rowHeaderLayer);
        this.treeLayer = treeLayer;
    }

    @Override
    protected void paintHiddenColumnIndicator(ILayer layer, GC gc, int xOffset, int yOffset, Rectangle rectangle) {
        if (this.columnHeaderLayer != null) {
            int lineAdjustment = gc.getLineWidth() % 2;
            int height = this.columnHeaderLayer.getHeight();

            for (int col = 0; col < layer.getColumnCount(); col++) {
                LabelStack configLabels = layer.getConfigLabelsByPosition(col, this.columnHeaderLayer.getRowCount());
                if (configLabels.hasLabel(HideIndicatorConstants.COLUMN_LEFT_HIDDEN)) {
                    // ensure that the current column and the left column belong
                    // to the same level
                    int currentLevel = this.treeLayer.getLevelByColumnIndex(layer.getColumnIndexByPosition(col));
                    int leftLevel = this.treeLayer.getLevelByColumnIndex(layer.getColumnIndexByPosition(col - 1));
                    if (currentLevel == leftLevel) {
                        int x = layer.getStartXOfColumnPosition(col);
                        if (this.rowHeaderLayer == null || x >= this.rowHeaderLayer.getWidth()) {
                            int start = rectangle.y;
                            for (int i = 0; i < this.columnHeaderLayer.getRowCount(); i++) {
                                ILayerCell cell = layer.getCellByPosition(col, i);
                                int cellStart = layer.getStartXOfColumnPosition(cell.getOriginColumnPosition());
                                if (cellStart < x
                                        && ((this.rowHeaderLayer != null && x > this.rowHeaderLayer.getWidth())
                                                || (this.rowHeaderLayer == null && x > 0))) {
                                    start += layer.getRowHeightByPosition(i);
                                }
                            }
                            gc.drawLine(x - lineAdjustment, start, x - lineAdjustment, height);
                        }
                    }
                }

                if (configLabels.hasLabel(HideIndicatorConstants.COLUMN_RIGHT_HIDDEN)) {
                    // ensure that the current column and the right column
                    // belong to the same level
                    int currentLevel = this.treeLayer.getLevelByColumnIndex(layer.getColumnIndexByPosition(col));
                    int rightPos = LayerUtil.convertColumnPosition(layer, col + 1, this.treeLayer);
                    int rightIndex = layer.getColumnIndexByPosition(rightPos);

                    int rightLevel = this.treeLayer.getLevelByColumnIndex(rightIndex);
                    if (currentLevel == rightLevel || (rightIndex < 0 && !this.treeLayer.isLevelHeaderColumn(rightPos))) {
                        // render the line on the right side of the last column
                        int x = layer.getStartXOfColumnPosition(col) + layer.getColumnWidthByPosition(col);
                        // adjust the rendering for the whole line width to
                        // avoid overlapping
                        if (col == layer.getColumnCount() - 1) {
                            lineAdjustment = (gc.getLineWidth() / 2) + lineAdjustment;
                        }
                        if (this.rowHeaderLayer == null || x >= this.rowHeaderLayer.getWidth()) {
                            int start = rectangle.y;
                            for (int i = 0; i < this.columnHeaderLayer.getRowCount(); i++) {
                                ILayerCell cell = layer.getCellByPosition(col + 1, i);
                                if (cell != null
                                        && cell.getOriginColumnPosition() < cell.getColumnPosition()
                                        && x < (cell.getBounds().x + cell.getBounds().width)) {
                                    start += layer.getRowHeightByPosition(i);
                                }
                            }
                            gc.drawLine(x - lineAdjustment, start, x - lineAdjustment, height - 1);
                        }
                    }
                }
            }
        }
    }

    @Override
    protected void paintHiddenRowIndicator(ILayer layer, GC gc, int xOffset, int yOffset, Rectangle rectangle) {
        // just in case there is a composition with a row header layer and a
        // HierarchicalTreeLayer
        super.paintHiddenRowIndicator(layer, gc, xOffset, yOffset, rectangle);

        int lineAdjustment = gc.getLineWidth() % 2;

        int startRow = this.columnHeaderLayer == null ? 0 : this.columnHeaderLayer.getRowCount();
        for (int col = 0; col < layer.getColumnCount(); col++) {
            LabelStack labels = layer.getConfigLabelsByPosition(col, startRow);
            if (labels.hasLabel(HierarchicalTreeLayer.LEVEL_HEADER_CELL)) {
                for (int row = startRow; row < layer.getRowCount(); row++) {
                    // get labels for column + 1 to reach the body without
                    // the level header
                    LabelStack configLabels = layer.getConfigLabelsByPosition(col + 1, row);
                    if (configLabels.hasLabel(HideIndicatorConstants.ROW_TOP_HIDDEN)) {
                        int y = layer.getStartYOfRowPosition(row);
                        if (this.columnHeaderLayer == null || y >= this.columnHeaderLayer.getHeight()) {
                            ILayerCell cell = layer.getCellByPosition(col, row);
                            int cellStart = layer.getStartYOfRowPosition(cell.getOriginRowPosition());
                            if (cellStart == y) {
                                int startX = layer.getStartXOfColumnPosition(col);
                                gc.drawLine(
                                        startX,
                                        y - lineAdjustment,
                                        startX + layer.getColumnWidthByPosition(col),
                                        y - lineAdjustment);
                            }
                        }
                    }

                    if (configLabels.hasLabel(HideIndicatorConstants.ROW_BOTTOM_HIDDEN)) {
                        int y = layer.getStartYOfRowPosition(row) + layer.getRowHeightByPosition(row);
                        // adjust the rendering for the whole line width to
                        // avoid overlapping
                        if (row == layer.getRowCount() - 1) {
                            lineAdjustment = (gc.getLineWidth() / 2) + lineAdjustment;
                        }
                        if (this.columnHeaderLayer == null || y >= this.columnHeaderLayer.getHeight()) {
                            ILayerCell cell = layer.getCellByPosition(col, row);
                            int cellStart = layer.getStartYOfRowPosition(cell.getOriginRowPosition());
                            if (cellStart == y) {
                                int startX = layer.getStartXOfColumnPosition(col);
                                gc.drawLine(
                                        startX,
                                        y - lineAdjustment,
                                        startX + layer.getColumnWidthByPosition(col),
                                        y - lineAdjustment);
                            }
                        }
                    }
                }
            }
        }
    }
}