/*
 * Copyright (C) 2010 The Android Open Source Project
 *
 * Licensed under the Eclipse Public License, Version 1.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.eclipse.org/org/documents/epl-v10.php
 *
 * 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.android.ide.common.layout;

import static com.android.SdkConstants.ANDROID_URI;
import static com.android.SdkConstants.ATTR_ID;
import static com.android.SdkConstants.ATTR_LAYOUT_HEIGHT;
import static com.android.SdkConstants.ATTR_LAYOUT_WIDTH;
import static com.android.SdkConstants.ATTR_ORIENTATION;
import static com.android.SdkConstants.VALUE_HORIZONTAL;
import static com.android.SdkConstants.VALUE_VERTICAL;

import com.android.ide.common.api.DropFeedback;
import com.android.ide.common.api.IAttributeInfo.Format;
import com.android.ide.common.api.IDragElement;
import com.android.ide.common.api.IMenuCallback;
import com.android.ide.common.api.INode;
import com.android.ide.common.api.IViewRule;
import com.android.ide.common.api.Point;
import com.android.ide.common.api.Rect;
import com.android.ide.common.api.RuleAction;
import com.android.ide.common.api.RuleAction.NestedAction;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;

/** Test the {@link LinearLayoutRule} */
public class LinearLayoutRuleTest extends LayoutTestBase {
    // Utility for other tests
    protected void dragIntoEmpty(Rect dragBounds) {
        boolean haveBounds = dragBounds.isValid();

        IViewRule rule = new LinearLayoutRule();

        INode targetNode = TestNode.create("android.widget.LinearLayout").id(
        "@+id/LinearLayout01").bounds(new Rect(0, 0, 240, 480));
        Point dropPoint = new Point(10, 5);

        IDragElement[] elements = TestDragElement.create(TestDragElement.create(
                "android.widget.Button", dragBounds).id("@+id/Button01"));

        // Enter target
        DropFeedback feedback = rule.onDropEnter(targetNode, null/*targetView*/, elements);
        assertNotNull(feedback);
        assertFalse(feedback.invalidTarget);
        assertNotNull(feedback.painter);

        feedback = rule.onDropMove(targetNode, elements, feedback, dropPoint);
        assertNotNull(feedback);
        assertFalse(feedback.invalidTarget);

        // Paint feedback and make sure it's what we expect
        TestGraphics graphics = new TestGraphics();
        assertNotNull(feedback.painter);
        feedback.painter.paint(graphics, targetNode, feedback);
        assertEquals(
                // Expect to see a recipient rectangle around the bounds of the
                // LinearLayout,
                // as well as a single vertical line as a drop preview located
                // along the left
                // edge (for this horizontal linear layout) showing insert
                // position at index 0,
                // and finally a rectangle for the bounds of the inserted button
                // centered over
                // the middle
                "[useStyle(DROP_RECIPIENT), "
                        +
                        // Bounds rectangle
                        "drawRect(Rect[0,0,240,480]), "
                        + "useStyle(DROP_ZONE), drawLine(1,0,1,480), "
                        + "useStyle(DROP_ZONE_ACTIVE), " + "useStyle(DROP_PREVIEW), " +
                        // Insert position line
                        "drawLine(1,0,1,480)" + (haveBounds ?
                        // Outline of dragged node centered over position line
                        ", useStyle(DROP_PREVIEW), " + "drawRect(1,0,101,80)"
                                // Nothing when we don't have bounds
                                : "") + "]", graphics.getDrawn().toString());

        // Attempt a drop
        assertEquals(0, targetNode.getChildren().length);
        rule.onDropped(targetNode, elements, feedback, dropPoint);
        assertEquals(1, targetNode.getChildren().length);
        assertEquals("@+id/Button01", targetNode.getChildren()[0].getStringAttr(
                ANDROID_URI, ATTR_ID));
    }

    // Utility for other tests
    protected INode dragInto(boolean vertical, Rect dragBounds, Point dragPoint,
            int insertIndex, int currentIndex,
            String... graphicsFragments) {
        INode linearLayout = TestNode.create("android.widget.LinearLayout").id(
                "@+id/LinearLayout01").bounds(new Rect(0, 0, 240, 480)).set(ANDROID_URI,
                ATTR_ORIENTATION,
                vertical ? VALUE_VERTICAL : VALUE_HORIZONTAL)
                .add(
                        TestNode.create("android.widget.Button").id("@+id/Button01").bounds(
                                new Rect(0, 0, 100, 80)),
                        TestNode.create("android.widget.Button").id("@+id/Button02").bounds(
                                new Rect(0, 100, 100, 80)),
                        TestNode.create("android.widget.Button").id("@+id/Button03").bounds(
                                new Rect(0, 200, 100, 80)),
                        TestNode.create("android.widget.Button").id("@+id/Button04").bounds(
                                new Rect(0, 300, 100, 80)));

        return super.dragInto(new LinearLayoutRule(), linearLayout, dragBounds, dragPoint, null,
                insertIndex, currentIndex, graphicsFragments);
    }

    // Check that the context menu registers the expected menu items
    public void testContextMenu() {
        LinearLayoutRule rule = new LinearLayoutRule();
        initialize(rule, "android.widget.LinearLayout");
        INode node = TestNode.create("android.widget.Button").id("@+id/Button012");

        List<RuleAction> contextMenu = new ArrayList<RuleAction>();
        rule.addContextMenuActions(contextMenu, node);
        assertEquals(6, contextMenu.size());
        assertEquals("Edit ID...", contextMenu.get(0).getTitle());
        assertTrue(contextMenu.get(1) instanceof RuleAction.Separator);
        assertEquals("Layout Width", contextMenu.get(2).getTitle());
        assertEquals("Layout Height", contextMenu.get(3).getTitle());
        assertTrue(contextMenu.get(4) instanceof RuleAction.Separator);
        assertEquals("Other Properties", contextMenu.get(5).getTitle());

        RuleAction propertiesMenu = contextMenu.get(5);
        assertTrue(propertiesMenu.getClass().getName(),
                propertiesMenu instanceof NestedAction);
    }

    public void testContextMenuCustom() {
        LinearLayoutRule rule = new LinearLayoutRule();
        initialize(rule, "android.widget.LinearLayout");
        INode node = TestNode.create("android.widget.LinearLayout").id("@+id/LinearLayout")
            .set(ANDROID_URI, ATTR_LAYOUT_WIDTH, "42dip")
            .set(ANDROID_URI, ATTR_LAYOUT_HEIGHT, "50sp");

        List<RuleAction> contextMenu = new ArrayList<RuleAction>();
        rule.addContextMenuActions(contextMenu, node);
        assertEquals(6, contextMenu.size());
        assertEquals("Layout Width", contextMenu.get(2).getTitle());
        RuleAction menuAction = contextMenu.get(2);
        assertTrue(menuAction instanceof RuleAction.Choices);
        RuleAction.Choices choices = (RuleAction.Choices) menuAction;
        List<String> titles = choices.getTitles();
        List<String> ids = choices.getIds();
        assertEquals("Wrap Content", titles.get(0));
        assertEquals("wrap_content", ids.get(0));
        assertEquals("Match Parent", titles.get(1));
        assertEquals("match_parent", ids.get(1));
        assertEquals("42dip", titles.get(2));
        assertEquals("42dip", ids.get(2));
        assertEquals("42dip", choices.getCurrent());
    }

    // Check that the context menu manipulates the orientation attribute
    public void testOrientation() {
        LinearLayoutRule rule = new LinearLayoutRule();
        initialize(rule, "android.widget.LinearLayout");
        TestNode node = TestNode.create("android.widget.LinearLayout").id("@+id/LinearLayout012");
        node.putAttributeInfo(ANDROID_URI, "orientation",
                new TestAttributeInfo(ATTR_ORIENTATION, Format.ENUM_SET,
                        "android.widget.LinearLayout",
                        new String[] {"horizontal", "vertical"}, null, null));

        assertNull(node.getStringAttr(ANDROID_URI, ATTR_ORIENTATION));

        List<RuleAction> contextMenu = new ArrayList<RuleAction>();
        rule.addContextMenuActions(contextMenu, node);
        assertEquals(7, contextMenu.size());
        RuleAction orientationAction = contextMenu.get(1);
        assertEquals("Orientation", orientationAction.getTitle());

        assertTrue(orientationAction.getClass().getName(),
                orientationAction instanceof RuleAction.Choices);

        RuleAction.Choices choices = (RuleAction.Choices) orientationAction;
        IMenuCallback callback = choices.getCallback();
        callback.action(orientationAction, Collections.singletonList(node), VALUE_VERTICAL, true);

        String orientation = node.getStringAttr(ANDROID_URI,
                ATTR_ORIENTATION);
        assertEquals(VALUE_VERTICAL, orientation);
        callback.action(orientationAction, Collections.singletonList(node), VALUE_HORIZONTAL,
                true);
        orientation = node.getStringAttr(ANDROID_URI, ATTR_ORIENTATION);
        assertEquals(VALUE_HORIZONTAL, orientation);
    }

    // Check that the context menu manipulates the orientation attribute
    public void testProperties() {
        LinearLayoutRule rule = new LinearLayoutRule();
        initialize(rule, "android.widget.LinearLayout");
        TestNode node = TestNode.create("android.widget.LinearLayout").id("@+id/LinearLayout012");
        node.putAttributeInfo(ANDROID_URI, "orientation",
                new TestAttributeInfo(ATTR_ORIENTATION, Format.ENUM_SET,
                        "android.widget.LinearLayout",
                        new String[] {"horizontal", "vertical"}, null, null));
        node.setAttributeSources(Arrays.asList("android.widget.LinearLayout",
                "android.view.ViewGroup", "android.view.View"));
        node.putAttributeInfo(ANDROID_URI, "gravity",
                new TestAttributeInfo("gravity", Format.INTEGER_SET,
                        "android.widget.LinearLayout", null, null, null));


        assertNull(node.getStringAttr(ANDROID_URI, ATTR_ORIENTATION));

        List<RuleAction> contextMenu = new ArrayList<RuleAction>();
        rule.addContextMenuActions(contextMenu, node);
        assertEquals(8, contextMenu.size());

        assertEquals("Orientation", contextMenu.get(1).getTitle());
        assertEquals("Edit Gravity...", contextMenu.get(2).getTitle());

        assertEquals("Other Properties", contextMenu.get(7).getTitle());

        RuleAction propertiesMenu = contextMenu.get(7);
        assertTrue(propertiesMenu.getClass().getName(),
                propertiesMenu instanceof NestedAction);
        NestedAction nested = (NestedAction) propertiesMenu;
        List<RuleAction> nestedActions = nested.getNestedActions(node);
        assertEquals(9, nestedActions.size());
        assertEquals("Recent", nestedActions.get(0).getTitle());
        assertTrue(nestedActions.get(1) instanceof RuleAction.Separator);
        assertEquals("Defined by LinearLayout", nestedActions.get(2).getTitle());
        assertEquals("Inherited from ViewGroup", nestedActions.get(3).getTitle());
        assertEquals("Inherited from View", nestedActions.get(4).getTitle());
        assertTrue(nestedActions.get(5) instanceof RuleAction.Separator);
        assertEquals("Layout Parameters", nestedActions.get(6).getTitle());
        assertTrue(nestedActions.get(7) instanceof RuleAction.Separator);
        assertEquals("All By Name", nestedActions.get(8).getTitle());

        BaseViewRule.editedProperty(ATTR_ORIENTATION);

        RuleAction recentAction = nestedActions.get(0);
        assertTrue(recentAction instanceof NestedAction);
        NestedAction recentChoices = (NestedAction) recentAction;
        List<RuleAction> recentItems = recentChoices.getNestedActions(node);

        assertEquals(1, recentItems.size());
        assertEquals("Orientation", recentItems.get(0).getTitle());

        BaseViewRule.editedProperty("gravity");
        recentItems = recentChoices.getNestedActions(node);
        assertEquals(2, recentItems.size());
        assertEquals("Gravity...", recentItems.get(0).getTitle());
        assertEquals("Orientation", recentItems.get(1).getTitle());

        BaseViewRule.editedProperty(ATTR_ORIENTATION);
        recentItems = recentChoices.getNestedActions(node);
        assertEquals(2, recentItems.size());
        assertEquals("Orientation", recentItems.get(0).getTitle());
        assertEquals("Gravity...", recentItems.get(1).getTitle());

        // Lots of other properties -- flushes out properties that apply to this view
        for (int i = 0; i < 30; i++) {
            BaseViewRule.editedProperty("dummy_" + i);
        }
        recentItems = recentChoices.getNestedActions(node);
        assertEquals(0, recentItems.size());

        BaseViewRule.editedProperty("gravity");
        recentItems = recentChoices.getNestedActions(node);
        assertEquals(1, recentItems.size());
        assertEquals("Gravity...", recentItems.get(0).getTitle());
    }

    public void testDragInEmptyWithBounds() {
        dragIntoEmpty(new Rect(0, 0, 100, 80));
    }

    public void testDragInEmptyWithoutBounds() {
        dragIntoEmpty(new Rect(0, 0, 0, 0));
    }

    public void testDragInVerticalTop() {
        dragInto(true,
                // Bounds of the dragged item
                new Rect(0, 0, 105, 80),
                // Drag point
                new Point(30, -10),
                // Expected insert location
                0,
                // Not dragging one of the existing children
                -1,
                // Bounds rectangle
                "useStyle(DROP_RECIPIENT), drawRect(Rect[0,0,240,480])",

                // Drop zones
                "useStyle(DROP_ZONE), drawLine(0,0,240,0), drawLine(0,90,240,90), "
                        + "drawLine(0,190,240,190), drawLine(0,290,240,290), "
                        + "drawLine(0,381,240,381)",

                // Active nearest line
                "useStyle(DROP_ZONE_ACTIVE), useStyle(DROP_PREVIEW), drawLine(0,0,240,0)",

                // Preview of the dropped rectangle
                "useStyle(DROP_PREVIEW), drawRect(0,-40,105,40)");

        // Without drag bounds it should be identical except no preview
        // rectangle
        dragInto(true,
                new Rect(0, 0, 0, 0), // Invalid
                new Point(30, -10), 0, -1,
                "useStyle(DROP_ZONE_ACTIVE), useStyle(DROP_PREVIEW), drawLine(0,0,240,0)");
    }

    public void testDragInVerticalBottom() {
        dragInto(true,
                // Bounds of the dragged item
                new Rect(0, 0, 105, 80),
                // Drag point
                new Point(30, 500),
                // Expected insert location
                4,
                // Not dragging one of the existing children
                -1,
                // Bounds rectangle
                "useStyle(DROP_RECIPIENT), drawRect(Rect[0,0,240,480])",

                // Drop zones
                "useStyle(DROP_ZONE), drawLine(0,0,240,0), drawLine(0,90,240,90), "
                        + "drawLine(0,190,240,190), drawLine(0,290,240,290), drawLine(0,381,240,381), ",

                // Active nearest line
                "useStyle(DROP_ZONE_ACTIVE), useStyle(DROP_PREVIEW), drawLine(0,381,240,381)",

                // Preview of the dropped rectangle
                "useStyle(DROP_PREVIEW), drawRect(0,381,105,461)");

        // Check without bounds too
        dragInto(true, new Rect(0, 0, 105, 80), new Point(30, 500), 4, -1,
                "useStyle(DROP_PREVIEW), drawRect(0,381,105,461)");
    }

    public void testDragInVerticalMiddle() {
        dragInto(true,
                // Bounds of the dragged item
                new Rect(0, 0, 105, 80),
                // Drag point
                new Point(0, 170),
                // Expected insert location
                2,
                // Not dragging one of the existing children
                -1,
                // Bounds rectangle
                "useStyle(DROP_RECIPIENT), drawRect(Rect[0,0,240,480])",

                // Drop zones
                "useStyle(DROP_ZONE), drawLine(0,0,240,0), drawLine(0,90,240,90), "
                        + "drawLine(0,190,240,190), drawLine(0,290,240,290)",

                // Active nearest line
                "useStyle(DROP_ZONE_ACTIVE), useStyle(DROP_PREVIEW), drawLine(0,190,240,190)",

                // Preview of the dropped rectangle
                "useStyle(DROP_PREVIEW), drawRect(0,150,105,230)");

        // Check without bounds too
        dragInto(true, new Rect(0, 0, 105, 80), new Point(0, 170), 2, -1,
                "useStyle(DROP_PREVIEW), drawRect(0,150,105,230)");
    }

    public void testDragInVerticalMiddleSelfPos() {
        // Drag the 2nd button, down to the position between 3rd and 4th
        dragInto(true,
                // Bounds of the dragged item
                new Rect(0, 100, 100, 80),
                // Drag point
                new Point(0, 250),
                // Expected insert location
                2,
                // Dragging 1st item
                1,
                // Bounds rectangle

                "useStyle(DROP_RECIPIENT), drawRect(Rect[0,0,240,480])",

                // Drop zones - these are different because we exclude drop
                // zones around the
                // dragged item itself (it doesn't make sense to insert directly
                // before or after
                // myself
                "useStyle(DROP_ZONE), drawLine(0,0,240,0), drawLine(0,290,240,290), "
                        + "drawLine(0,381,240,381)",

                // Preview line along insert axis
                "useStyle(DROP_ZONE_ACTIVE), useStyle(DROP_PREVIEW), drawLine(0,290,240,290)",

                // Preview of dropped rectangle
                "useStyle(DROP_PREVIEW), drawRect(0,250,100,330)");

        // Test dropping on self (no position change):
        dragInto(true,
                // Bounds of the dragged item
                new Rect(0, 100, 100, 80),
                // Drag point
                new Point(0, 210),
                // Expected insert location
                1,
                // Dragging from same pos
                1,
                // Bounds rectangle
                "useStyle(DROP_RECIPIENT), drawRect(Rect[0,0,240,480])",

                // Drop zones - these are different because we exclude drop
                // zones around the
                // dragged item itself (it doesn't make sense to insert directly
                // before or after
                // myself
                "useStyle(DROP_ZONE), drawLine(0,0,240,0), drawLine(0,290,240,290), "
                        + "drawLine(0,381,240,381)",

                // No active nearest line when you're over the self pos!

                // Preview of the dropped rectangle
                "useStyle(DROP_ZONE_ACTIVE), useStyle(DROP_PREVIEW), drawRect(0,100,100,180)");
    }

    public void testDragToLastPosition() {
        // Drag a button to the last position -- and confirm that the preview rectangle
        // is now shown midway between the second to last and last positions, but fully
        // below the drop zone line:
        dragInto(true,
                // Bounds of the dragged item
                new Rect(0, 100, 100, 80),
                // Drag point
                new Point(0, 400),
                // Expected insert location
                3,
                // Dragging 1st item
                1,

                // Bounds rectangle
                "useStyle(DROP_RECIPIENT), drawRect(Rect[0,0,240,480])",

                // Drop Zones
                "useStyle(DROP_ZONE), drawLine(0,0,240,0), drawLine(0,290,240,290), " +
                "drawLine(0,381,240,381), ",

                // Active Drop Zone
                "useStyle(DROP_ZONE_ACTIVE), useStyle(DROP_PREVIEW), drawLine(0,381,240,381)",

                // Drop Preview
                "useStyle(DROP_PREVIEW), drawRect(0,381,100,461)");
    }

    // Left to test:
    // Check inserting at last pos with multiple children
    // Check inserting with no bounds rectangle for dragged element
}