/*******************************************************************************
 * Copyright (c) 2016, 2020 Dirk Fauth and others.
 *
 * 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.examples._500_Layers._504_Viewport;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.eclipse.nebula.widgets.nattable.NatTable;
import org.eclipse.nebula.widgets.nattable.command.ILayerCommand;
import org.eclipse.nebula.widgets.nattable.data.ExtendedReflectiveColumnPropertyAccessor;
import org.eclipse.nebula.widgets.nattable.data.IColumnPropertyAccessor;
import org.eclipse.nebula.widgets.nattable.data.IDataProvider;
import org.eclipse.nebula.widgets.nattable.data.ListDataProvider;
import org.eclipse.nebula.widgets.nattable.data.ReflectiveColumnPropertyAccessor;
import org.eclipse.nebula.widgets.nattable.dataset.person.PersonService;
import org.eclipse.nebula.widgets.nattable.dataset.person.PersonWithAddress;
import org.eclipse.nebula.widgets.nattable.examples.AbstractNatExample;
import org.eclipse.nebula.widgets.nattable.examples.runner.StandaloneNatExampleRunner;
import org.eclipse.nebula.widgets.nattable.grid.GridRegion;
import org.eclipse.nebula.widgets.nattable.grid.data.DefaultColumnHeaderDataProvider;
import org.eclipse.nebula.widgets.nattable.grid.data.DefaultCornerDataProvider;
import org.eclipse.nebula.widgets.nattable.grid.data.DefaultRowHeaderDataProvider;
import org.eclipse.nebula.widgets.nattable.grid.layer.ColumnHeaderLayer;
import org.eclipse.nebula.widgets.nattable.grid.layer.CornerLayer;
import org.eclipse.nebula.widgets.nattable.grid.layer.DefaultColumnHeaderDataLayer;
import org.eclipse.nebula.widgets.nattable.grid.layer.DefaultRowHeaderDataLayer;
import org.eclipse.nebula.widgets.nattable.grid.layer.DimensionallyDependentIndexLayer;
import org.eclipse.nebula.widgets.nattable.grid.layer.RowHeaderLayer;
import org.eclipse.nebula.widgets.nattable.layer.AbstractIndexLayerTransform;
import org.eclipse.nebula.widgets.nattable.layer.AbstractLayer;
import org.eclipse.nebula.widgets.nattable.layer.CompositeLayer;
import org.eclipse.nebula.widgets.nattable.layer.DataLayer;
import org.eclipse.nebula.widgets.nattable.layer.ILayer;
import org.eclipse.nebula.widgets.nattable.layer.IUniqueIndexLayer;
import org.eclipse.nebula.widgets.nattable.layer.LabelStack;
import org.eclipse.nebula.widgets.nattable.painter.IOverlayPainter;
import org.eclipse.nebula.widgets.nattable.painter.layer.CellLayerPainter;
import org.eclipse.nebula.widgets.nattable.resize.action.VerticalResizeCursorAction;
import org.eclipse.nebula.widgets.nattable.selection.SelectionLayer;
import org.eclipse.nebula.widgets.nattable.selection.SelectionLayerPainter;
import org.eclipse.nebula.widgets.nattable.selection.command.ClearAllSelectionsCommand;
import org.eclipse.nebula.widgets.nattable.selection.command.SelectAllCommand;
import org.eclipse.nebula.widgets.nattable.selection.command.SelectCellCommand;
import org.eclipse.nebula.widgets.nattable.ui.action.IDragMode;
import org.eclipse.nebula.widgets.nattable.ui.matcher.MouseEventMatcher;
import org.eclipse.nebula.widgets.nattable.util.ClientAreaAdapter;
import org.eclipse.nebula.widgets.nattable.util.GUIHelper;
import org.eclipse.nebula.widgets.nattable.viewport.SliderScroller;
import org.eclipse.nebula.widgets.nattable.viewport.ViewportLayer;
import org.eclipse.nebula.widgets.nattable.viewport.command.RecalculateScrollBarsCommand;
import org.eclipse.nebula.widgets.nattable.viewport.command.ViewportSelectColumnCommand;
import org.eclipse.nebula.widgets.nattable.viewport.command.ViewportSelectRowCommand;
import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.ScrolledComposite;
import org.eclipse.swt.events.MouseEvent;
import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.graphics.GC;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.layout.FillLayout;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Slider;

/**
 *
 */
public class _5046_MultiScrollExample extends AbstractNatExample {

    public static void main(String[] args) throws Exception {
        StandaloneNatExampleRunner.run(600, 400, new _5046_MultiScrollExample());
    }

    @Override
    public String getDescription() {
        return "This example shows multiple scrollable regions.";
    }

    @Override
    public Control createExampleControl(Composite parent) {

        List<PersonWithAddress> values = PersonService.getPersonsWithAddress(10);

        ContentBodyLayerStack contentBodyLayer = new ContentBodyLayerStack(values);
        StructureBodyLayerStack structureBodyLayer = new StructureBodyLayerStack(values, contentBodyLayer);

        // build the column header layer
        IDataProvider contentHeaderDataProvider =
                new DefaultColumnHeaderDataProvider(contentBodyLayer.propertyNames, contentBodyLayer.propertyToLabelMap);
        DataLayer contentHeaderDataLayer =
                new DefaultColumnHeaderDataLayer(contentHeaderDataProvider);
        AbstractLayer contentColumnHeaderLayer =
                new ColumnHeaderLayer(contentHeaderDataLayer, contentBodyLayer, contentBodyLayer.getSelectionLayer());

        IDataProvider structureHeaderDataProvider =
                new DefaultColumnHeaderDataProvider(structureBodyLayer.propertyNames, structureBodyLayer.propertyToLabelMap);
        DataLayer structureHeaderDataLayer =
                new DefaultColumnHeaderDataLayer(structureHeaderDataProvider);
        ColumnHeaderLayer structureColumnHeaderLayer =
                new ColumnHeaderLayer(structureHeaderDataLayer, structureBodyLayer, structureBodyLayer.selectionLayer);
        structureColumnHeaderLayer.setVerticalLayerDependency(contentColumnHeaderLayer);

        DataLayer rowHeaderDataLayer =
                new DefaultRowHeaderDataLayer(new DefaultRowHeaderDataProvider(contentBodyLayer.bodyDataProvider));
        ILayer rowHeaderLayer =
                new RowHeaderLayer(rowHeaderDataLayer, contentBodyLayer, (SelectionLayer) null);

        // build the corner layer
        IDataProvider cornerDataProvider =
                new DefaultCornerDataProvider(contentHeaderDataProvider, rowHeaderDataLayer.getDataProvider());
        DataLayer cornerDataLayer =
                new DataLayer(cornerDataProvider);
        ILayer cornerLayer =
                new CornerLayer(cornerDataLayer, rowHeaderLayer, contentColumnHeaderLayer);

        ExtendedGridLayer gridLayer = new ExtendedGridLayer(
                contentBodyLayer, contentColumnHeaderLayer,
                structureBodyLayer, structureColumnHeaderLayer,
                rowHeaderLayer, cornerLayer);

        // MULTI-VIEWPORT-CONFIGURATION

        // as the CompositeLayer is setting a IClientAreaProvider for the
        // composition we need to set a special ClientAreaAdapter after the
        // creation of the CompositeLayer to support split viewports
        int leftWidth = 80;
        ClientAreaAdapter leftClientAreaAdapter =
                new ClientAreaAdapter(structureBodyLayer.getViewportLayer().getClientAreaProvider());
        leftClientAreaAdapter.setWidth(leftWidth);
        structureBodyLayer.getViewportLayer().setClientAreaProvider(leftClientAreaAdapter);

        structureBodyLayer.getViewportLayer().setVerticalScrollbarEnabled(false);

        // use a cell layer painter that is configured for left clipping
        // this ensures that the rendering works correctly for split
        // viewports
        contentBodyLayer.getSelectionLayer().setLayerPainter(new SelectionLayerPainter(true, false));

        contentColumnHeaderLayer.setLayerPainter(new CellLayerPainter(true, false));

        ScrolledComposite sc = new ScrolledComposite(parent, SWT.H_SCROLL | SWT.V_SCROLL);

        // Wrap NatTable in composite so we can slap on the external horizontal
        // sliders
        Composite composite = new Composite(sc, SWT.NONE);
        GridLayout gridLayout = new GridLayout(1, false);
        gridLayout.marginHeight = 0;
        gridLayout.marginWidth = 0;
        gridLayout.horizontalSpacing = 0;
        gridLayout.verticalSpacing = 0;
        composite.setLayout(gridLayout);

        NatTable natTable = new NatTable(composite, gridLayer);
        GridData gridData = new GridData();
        gridData.horizontalAlignment = GridData.FILL;
        gridData.verticalAlignment = GridData.FILL;
        gridData.grabExcessHorizontalSpace = true;
        gridData.grabExcessVerticalSpace = true;
        natTable.setLayoutData(gridData);

        createSplitSliders(composite, gridLayer, rowHeaderLayer.getWidth());

        sc.setContent(composite);

        sc.setExpandHorizontal(true);
        sc.setExpandVertical(true);
        updateScrolledCompositeSize(sc, gridLayer);

        // add an IOverlayPainter to render the split viewport border
        natTable.addOverlayPainter(new IOverlayPainter() {

            @Override
            public void paintOverlay(GC gc, ILayer layer) {
                Color beforeColor = gc.getForeground();
                gc.setForeground(GUIHelper.COLOR_GRAY);
                int viewportBorderX = rowHeaderLayer.getWidth() + gridLayer.getStructureBody().getWidth() - 1;
                gc.drawLine(viewportBorderX, 0, viewportBorderX, layer.getHeight() - 1);
                gc.setForeground(beforeColor);
            }
        });

        // Mouse move - Show resize cursor
        natTable.getUiBindingRegistry().registerFirstMouseMoveBinding(
                new ClientAreaResizeMatcher(gridLayer),
                new VerticalResizeCursorAction());

        natTable.getUiBindingRegistry().registerFirstMouseDragMode(
                new ClientAreaResizeMatcher(gridLayer),
                new ClientAreaResizeDragMode(gridLayer, sc));

        return natTable;
    }

    /**
     *
     * @param sc
     * @param gridLayer
     */
    private void updateScrolledCompositeSize(ScrolledComposite sc, ExtendedGridLayer gridLayer) {
        sc.setMinSize(
                gridLayer.getRowHeaderLayer().getWidth() + gridLayer.getStructureBody().getWidth() + 100,
                gridLayer.getContentHeader().getHeight() + 20);
    }

    /**
     *
     * @param natTableParent
     * @param gridLayer
     * @param fixedHeaderWidth
     */
    private void createSplitSliders(
            Composite natTableParent, ExtendedGridLayer gridLayer, int fixedHeaderWidth) {
        Composite sliderComposite = new Composite(natTableParent, SWT.NONE);
        GridData gridData = new GridData();
        gridData.horizontalAlignment = GridData.FILL;
        gridData.grabExcessHorizontalSpace = true;
        gridData.grabExcessVerticalSpace = false;
        gridData.heightHint = 17;
        sliderComposite.setLayoutData(gridData);

        GridLayout gridLayout = new GridLayout(2, false);
        gridLayout.marginHeight = 0;
        gridLayout.marginWidth = 0;
        gridLayout.horizontalSpacing = 0;
        gridLayout.verticalSpacing = 0;
        sliderComposite.setLayout(gridLayout);

        // Slider Left
        // Need a composite here to set preferred size because Slider can't be
        // subclassed.
        Composite sliderLeftComposite = new Composite(sliderComposite, SWT.NONE) {
            @Override
            public Point computeSize(int wHint, int hHint, boolean changed) {
                int width = ((ClientAreaAdapter) gridLayer.getStructureBody().getViewportLayer().getClientAreaProvider()).getWidth() + fixedHeaderWidth;
                return new Point(width, 17);
            }
        };
        sliderLeftComposite.setLayout(new FillLayout());
        gridData = new GridData();
        gridData.horizontalAlignment = GridData.BEGINNING;
        gridData.verticalAlignment = GridData.BEGINNING;
        sliderLeftComposite.setLayoutData(gridData);

        Slider sliderLeft = new Slider(sliderLeftComposite, SWT.HORIZONTAL);
        gridData = new GridData();
        gridData.horizontalAlignment = GridData.FILL;
        gridData.verticalAlignment = GridData.FILL;
        sliderLeft.setLayoutData(gridData);

        gridLayer.getStructureBody().getViewportLayer().setHorizontalScroller(new SliderScroller(sliderLeft));

        // Slider Right
        Slider sliderRight = new Slider(sliderComposite, SWT.HORIZONTAL);
        gridData = new GridData();
        gridData.horizontalAlignment = GridData.FILL;
        gridData.verticalAlignment = GridData.BEGINNING;
        gridData.grabExcessHorizontalSpace = true;
        gridData.grabExcessVerticalSpace = false;
        sliderRight.setLayoutData(gridData);

        gridLayer.getContentBody().getViewportLayer().setHorizontalScroller(new SliderScroller(sliderRight));
    }

    /**
     *
     */
    class ExtendedGridLayer extends CompositeLayer {

        public ExtendedGridLayer(
                ContentBodyLayerStack contentBodyLayer, ILayer contentColumnHeaderLayer,
                StructureBodyLayerStack structureBodyLayer, ILayer structureColumnHeaderLayer,
                ILayer rowHeaderLayer, ILayer cornerLayer) {

            super(3, 2);

            setChildLayer(GridRegion.CORNER, cornerLayer, 0, 0);
            setChildLayer(GridRegion.ROW_HEADER, rowHeaderLayer, 0, 1);
            setChildLayer(GridRegion.COLUMN_HEADER, structureColumnHeaderLayer, 1, 0);
            setChildLayer(GridRegion.BODY, structureBodyLayer, 1, 1);
            setChildLayer(GridRegion.COLUMN_HEADER, contentColumnHeaderLayer, 2, 0);
            setChildLayer(GridRegion.BODY, contentBodyLayer, 2, 1);
        }

        public StructureBodyLayerStack getStructureBody() {
            return (StructureBodyLayerStack) getChildLayerByLayoutCoordinate(1, 1);
        }

        public ContentBodyLayerStack getContentBody() {
            return (ContentBodyLayerStack) getChildLayerByLayoutCoordinate(2, 1);
        }

        public ILayer getStructureHeader() {
            return getChildLayerByLayoutCoordinate(1, 0);
        }

        public ILayer getContentHeader() {
            return getChildLayerByLayoutCoordinate(2, 0);
        }

        public ILayer getRowHeaderLayer() {
            return getChildLayerByLayoutCoordinate(0, 1);
        }

        @Override
        protected boolean doCommandOnChildLayers(ILayerCommand command) {
            if (doCommandOnChildLayer(command, getContentBody())) {
                return true;
            } else if (doCommandOnChildLayer(command, getStructureBody())) {
                return true;
            } else if (doCommandOnChildLayer(command, getContentHeader())) {
                return true;
            } else if (doCommandOnChildLayer(command, getStructureHeader())) {
                return true;
            } else if (doCommandOnChildLayer(command, getRowHeaderLayer())) {
                return true;
            } else {
                return doCommandOnChildLayer(command, getChildLayerByLayoutCoordinate(0, 0));
            }
        }

        private boolean doCommandOnChildLayer(ILayerCommand command, ILayer childLayer) {
            ILayerCommand childCommand = command.cloneCommand();
            return childLayer.doCommand(childCommand);
        }

        @Override
        public boolean doCommand(ILayerCommand command) {
            if (command instanceof ViewportSelectRowCommand
                    || command instanceof ClearAllSelectionsCommand
                    || command instanceof SelectAllCommand) {
                doCommandOnChildLayer(command, getContentBody());
                doCommandOnChildLayer(command, getStructureBody());
                return true;
            } else if (command instanceof SelectCellCommand) {
                int layout = getLayoutXByColumnPosition(((SelectCellCommand) command).getColumnPosition());
                if (layout == 2) {
                    doCommandOnChildLayer(new ClearAllSelectionsCommand(), getStructureBody());
                } else {
                    doCommandOnChildLayer(new ClearAllSelectionsCommand(), getContentBody());
                }
            } else if (command instanceof ViewportSelectColumnCommand) {
                int layout = getLayoutXByColumnPosition(((ViewportSelectColumnCommand) command).getColumnPosition());
                if (layout == 2) {
                    doCommandOnChildLayer(new ClearAllSelectionsCommand(), getStructureBody());
                } else {
                    doCommandOnChildLayer(new ClearAllSelectionsCommand(), getContentBody());
                }
            }
            return super.doCommand(command);
        }
    }

    /**
     *
     */
    class ContentBodyLayerStack extends AbstractIndexLayerTransform {

        // property names of the Person class
        public final String[] propertyNames = { "firstName", "lastName", "gender", "married", "birthday" };

        // mapping from property to label, needed for column header labels
        public final Map<String, String> propertyToLabelMap = new HashMap<>();

        private final IDataProvider bodyDataProvider;
        private final DataLayer bodyDataLayer;
        private final SelectionLayer selectionLayer;
        private final ViewportLayer viewportLayer;

        public ContentBodyLayerStack(List<PersonWithAddress> values) {
            this.propertyToLabelMap.put("firstName", "Firstname");
            this.propertyToLabelMap.put("lastName", "Lastname");
            this.propertyToLabelMap.put("gender", "Gender");
            this.propertyToLabelMap.put("married", "Married");
            this.propertyToLabelMap.put("birthday", "Birthday");

            IColumnPropertyAccessor<PersonWithAddress> columnPropertyAccessor =
                    new ReflectiveColumnPropertyAccessor<>(this.propertyNames);

            this.bodyDataProvider = new ListDataProvider<>(values, columnPropertyAccessor);
            this.bodyDataLayer = new DataLayer(this.bodyDataProvider);
            this.selectionLayer = new SelectionLayer(this.bodyDataLayer);
            this.viewportLayer = new ViewportLayer(this.selectionLayer);

            setUnderlyingLayer(this.viewportLayer);
        }

        public ViewportLayer getViewportLayer() {
            return this.viewportLayer;
        }

        public SelectionLayer getSelectionLayer() {
            return this.selectionLayer;
        }
    }

    /**
     *
     */
    class StructureBodyLayerStack extends AbstractIndexLayerTransform {

        // property names of the Address class
        public final String[] propertyNames = { "address.street", "address.housenumber", "address.postalCode", "address.city" };

        // mapping from property to label, needed for column header labels
        public final Map<String, String> propertyToLabelMap = new HashMap<>();

        private final IDataProvider bodyDataProvider;
        private final DataLayer bodyDataLayer;
        private final SelectionLayer selectionLayer;
        private final ViewportLayer viewportLayer;

        public StructureBodyLayerStack(List<PersonWithAddress> values, IUniqueIndexLayer verticalDependency) {
            this.propertyToLabelMap.put("address.street", "Street");
            this.propertyToLabelMap.put("address.housenumber", "Housenumber");
            this.propertyToLabelMap.put("address.postalCode", "Postal Code");
            this.propertyToLabelMap.put("address.city", "City");

            IColumnPropertyAccessor<PersonWithAddress> columnPropertyAccessor =
                    new ExtendedReflectiveColumnPropertyAccessor<>(this.propertyNames);

            this.bodyDataProvider = new ListDataProvider<>(values, columnPropertyAccessor);
            this.bodyDataLayer = new DataLayer(this.bodyDataProvider);
            this.selectionLayer = new SelectionLayer(this.bodyDataLayer);
            this.viewportLayer = new ViewportLayer(this.selectionLayer);

            setUnderlyingLayer(new DimensionallyDependentIndexLayer(this.viewportLayer, this.viewportLayer, verticalDependency));
        }

        public ViewportLayer getViewportLayer() {
            return this.viewportLayer;
        }
    }

    /**
     *
     */
    class ClientAreaResizeMatcher extends MouseEventMatcher {

        ExtendedGridLayer gridLayer;

        public ClientAreaResizeMatcher(ExtendedGridLayer gridLayer) {
            this.gridLayer = gridLayer;
        }

        @Override
        public boolean matches(NatTable natTable, MouseEvent event, LabelStack regionLabels) {
            int viewportBorderX = this.gridLayer.getRowHeaderLayer().getWidth() + this.gridLayer.getStructureBody().getWidth();
            if (regionLabels != null && regionLabels.hasLabel(GridRegion.COLUMN_HEADER)
                    && (event.x >= viewportBorderX && event.x <= viewportBorderX + 4)) {
                return true;
            }
            return false;
        }
    }

    /**
     *
     */
    class ClientAreaResizeDragMode implements IDragMode {

        ExtendedGridLayer gridLayer;
        ScrolledComposite sc;

        public ClientAreaResizeDragMode(ExtendedGridLayer gridLayer, ScrolledComposite sc) {
            this.gridLayer = gridLayer;
            this.sc = sc;
        }

        @Override
        public void mouseDown(NatTable natTable, MouseEvent event) {
        }

        @Override
        public void mouseMove(NatTable natTable, MouseEvent event) {
            // TODO overlay support
        }

        @Override
        public void mouseUp(NatTable natTable, MouseEvent event) {
            int baseWidth = this.gridLayer.getStructureBody().bodyDataLayer.getWidth();
            int newWidth = event.x - this.gridLayer.getRowHeaderLayer().getWidth();
            if (newWidth < 0) {
                newWidth = 1;
            } else if (newWidth > baseWidth) {
                newWidth = baseWidth;
            }
            ((ClientAreaAdapter) this.gridLayer.getStructureBody().getViewportLayer().getClientAreaProvider()).setWidth(newWidth);

            this.gridLayer.getStructureBody().getViewportLayer().invalidateHorizontalStructure();
            this.gridLayer.getStructureBody().getViewportLayer().doCommand(new RecalculateScrollBarsCommand());

            this.gridLayer.getContentBody().getViewportLayer().invalidateHorizontalStructure();
            this.gridLayer.getContentBody().getViewportLayer().doCommand(new RecalculateScrollBarsCommand());

            natTable.redraw();
            natTable.getParent().layout(true, true);

            updateScrolledCompositeSize(this.sc, this.gridLayer);
        }

    }
}