package com.baidu.bdg.kg.gdb.query;

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

import com.baidu.bdg.kg.gdb.Graph;
import com.baidu.bdg.kg.gdb.model.Document;
import com.baidu.bdg.kg.gdb.model.DocumentType;
import com.baidu.bdg.kg.gdb.model.ID;

/**
 * <pre>
 * Graph Query接口
 * </pre>
 * 
 * @author arganzheng
 *
 */
public interface Query {

    /*
     * *****************************************************
     * 
     * builder
     * 
     * *****************************************************
     */
    public Query setGraph(Graph graph);

    public Query label(String label);

    public Query key(String...keys);

    public Query id(ID...ids);

    public Query has(String key, Predicate predicate, Object condition);

    public Query has(String key, Object value);

    public Query hasNot(String key, Object value);

    public Query interval(String key, Comparable<?> startValue, Comparable<?> endValue);

    public Query limit(int limit);

    public Query orderBy(String key);

    public Query orderBy(String key, Order order);

    public Query addOrder(String property, Order order);

    /**
     * 选择返回的字段，默认返回所有字段
     * 
     * @param properties
     */
    public Query values(String...properties);

    // DocumentType => Vertex
    public Query V();

    // DocumentType => Edge
    public Query E();

    /*
     * *****************************************************
     * 
     * execute query
     * 
     * *****************************************************
     */
    public DocumentIterator vertices();

    public DocumentIterator edges();

    public DocumentIterator execute();

    /**
     * Whether the given element matches the conditions of this query.
     * 
     * Used for result filtering if the result set returned by the query executor is not fitted.
     * 
     * @param document
     * @return
     */
    public boolean match(Document document);

    /*
     * *****************************************************
     * 
     * query traversal
     * 
     * *****************************************************
     */
    /**
     * Gets the outgoing edges to the vertex.
     * 
     * @return
     */
    public Query outE();

    /**
     * Gets the outgoing edges to the vertex.
     * 
     * @return
     */
    public Query outE(String label);

    /**
     * Get both outgoing tail vertex of the edge.
     * 
     * @return
     */
    public Query outV();

    /**
     * Get both outgoing tail vertex of the edge.
     * 
     * @return
     */
    public Query outV(String label);

    /**
     * Gets the out adjacent vertices to the vertex.
     * 
     * @return
     */
    public Query out();

    /**
     * Gets the out adjacent vertices to the vertex.
     * 
     * @return
     */
    public Query out(String label);

    /**
     * Gets the in adjacent vertices to the vertex.
     * 
     * @return
     */
    public Query in();

    /**
     * Gets the in adjacent vertices to the vertex.
     * 
     * @return
     */
    public Query in(String label);

    /**
     * Gets the ingoing edges to the vertex.
     * 
     * @return
     */
    public Query inE();

    /**
     * Gets the ingoing edges to the vertex.
     * 
     * @return
     */
    public Query inE(String label);

    /**
     * Get both ingoing tail vertex of the edge.
     * 
     * @return
     */
    public Query inV();

    /**
     * Get both ingoing tail vertex of the edge.
     * 
     * @return
     */
    public Query inV(String label);

    /*
     * *****************************************************
     * 
     * getter
     * 
     * *****************************************************
     */
    public Graph getGraph();

    public String getGraphName();

    public String getLabel();

    public OrderList getOrderList();

    public int getLimit();

    public List<String> getSelectedFields();

    public List<String> getKeys();

    public Map<String, List<ID>> getIds();

    public boolean hasIds();

    public DocumentType getDocumentType();

    public List<Condition<Document>> getConditions();
}

/**
 * <pre>
 * build the god family as Titan does.
 * @see http://s3.thinkaurelius.com/docs/titan/1.0.0/getting-started.html
 * </pre>
 */

@Test
public void testBuildGraphOfTheGodFamily() {
    // create index
    graph.createIndex("titan", "name", IndexType.STRING);
    graph.createIndex("titan", "age", IndexType.NUMERIC);

    graph.createIndex("god", "name", IndexType.STRING);
    graph.createIndex("god", "age", IndexType.NUMERIC);

    graph.createIndex("location", "name", IndexType.STRING);

    graph.createIndex("monster", "name", IndexType.STRING);

    graph.createIndex("lives", "reason", IndexType.STRING);

    graph.createIndex("battled", "time", IndexType.NUMERIC);

    // add vertex, here we use name as vertex key
    graph.addVertex(new Vertex("titan", "saturn").addProperties("name", "saturn", "age", 10000));
    graph.addVertex(new Vertex("location", "sky").addProperties("name", "sky"));
    graph.addVertex(new Vertex("location", "sea").addProperties("name", "sea"));
    graph.addVertex(new Vertex("god", "jupiter").addProperties("name", "jupiter", "age", 5000));
    graph.addVertex(new Vertex("god", "neptune").addProperties("name", "neptune", "age", 4500));
    graph.addVertex(new Vertex("demigod", "hercules").addProperties("name", "hercules", "age", 30));
    graph.addVertex(new Vertex("human", "alcmene").addProperties("name", "alcmene", "age", 45));
    graph.addVertex(new Vertex("god", "pluto").addProperties("name", "pluto", "age", 4000));
    graph.addVertex(new Vertex("monster", "nemean").addProperties("name", "nemean"));
    graph.addVertex(new Vertex("monster", "hydra").addProperties("name", "hydra"));
    graph.addVertex(new Vertex("monster", "cerberus").addProperties("name", "cerberus"));
    graph.addVertex(new Vertex("location", "tartarus").addProperties("name", "tartarus"));

    // add edges
    graph.addEdge("father", new ID("god", "jupiter"), new ID("titan", "saturn"));
    graph.addEdge("lives", new ID("god", "jupiter"), new ID("location", "sky"), new Property("reason",
            "loves fresh breezes"));
    graph.addEdge("lives", new ID("god", "neptune"), new ID("location", "sea"), new Property("reason",
            "loves wares"));

    graph.addEdge("brother", new ID("god", "jupiter"), new ID("god", "neptune"), true);
    graph.addEdge("brother", new ID("god", "jupiter"), new ID("god", "pluto"), true);
    graph.addEdge("brother", new ID("god", "neptune"), new ID("god", "pluto"), true);

    graph.addEdge("father", new ID("demigod", "hercules"), new ID("god", "jupiter"));
    graph.addEdge("mother", new ID("demigod", "pluto"), new ID("human", "jupiter"));

    graph.addEdge("battled", new ID("demigod", "hercules"), new ID("monster", "nemean"), new Property("time", 1));
    graph.addEdge("battled", new ID("demigod", "hercules"), new ID("monster", "hydra"), new Property("time", 2));
    graph.addEdge("battled", new ID("demigod", "hercules"), new ID("monster", "cerberus"), //
            new Property("time", 12));

    graph.addEdge("lives", new ID("god", "pluto"), new ID("location", "tartarus"), new Property("reason",
            "no fear of death"));
    graph.addEdge("pet", new ID("god", "pluto"), new ID("monster", "cerberus"));
    graph.addEdge("lives", new ID("monster", "cerberus"), new ID("location", "tartarus"));
}

@Test
public void testAddVertexWithJson() throws IOException {
    String label = "test";
    String filePath = this.getClass().getClassLoader().getResource("data/product.json").getFile();
    File file = new File(filePath);
    String productJsonData = Files.asCharSource(file, Charsets.UTF_8).read();
    Document doc = Document.fromJson(productJsonData);
    Vertex v = new Vertex(doc);
    v.setLabel(label); // 如果json数据没有label信息，需要设置一下
    graph.addVertex(v);

    Vertex result = graph.getVertex(label, "b928a3ff3534bd4b8a2b9c3e742b61d4");
    System.out.println(result);
    Assert.assertNotNull(result);
}

/**
 * Test Query the God Family Graph
 * 
 * @author arganzheng
 *
 */
public class AerospikeGraphQueryTest {

    /*
     * *****************************************************
     * 
     * Testcase Setup and Teardown
     * 
     * *****************************************************
     */
    public static boolean init = false;

    Graph graph = null;

    @Before
    public void setUp() {
        // create graph
        graph = new AerospikeGraph("test", true);
        // drop data first
        graph.dropData();
        // drop index also
        graph.dropIndex();

        // init test data
        buildTestGraph();
    }

    public void buildTestGraph() {
        String label = "Person";
        /** create index **/
        // create Index for name -- test equality index
        Index idxNameFirst = graph.createIndex(label, "name", IndexType.STRING);
        System.out.println("create index " + idxNameFirst);

        // create Index for age -- test range index
        Index idxAge = graph.createIndex(label, "age", IndexType.NUMERIC);
        System.out.println("create index " + idxAge);

        // create Index for address/city -- test nested index
        Index idxAddressCity = graph.createIndex(label, "address/city", IndexType.STRING);
        System.out.println("create index " + idxAddressCity);

        // create Index for tags -- test array index
        String tagsPath = "tags";
        IndexType tagsIndexType = IndexType.STRING;
        Index idxTags = graph.createArrayIndex(label, tagsPath, tagsIndexType);
        System.out.println("create index " + idxTags);

        /** add vertex 1 **/
        Vertex v1 = new Vertex("Person", "1");

        // add name property
        v1.addProperty("name", "argan");

        // add age property
        v1.addProperty("age", 31);

        // add address
        Map<String, String> address = new HashMap<>();
        address.put("province", "GD");
        address.put("city", "ShenZhen");
        v1.addProperty("address", address);

        // add tags property
        List<String> tags = Arrays.asList("smart", "handson", "rich");
        v1.addProperty("tags", tags);

        /** add vertex 2 **/
        Vertex v2 = new Vertex("Person", "2");

        // add name property
        v2.addProperty("name", "magi");

        // add age property
        v2.addProperty("age", 29);

        // add address
        Map<String, String> address2 = new HashMap<>();
        address2.put("province", "GD");
        address2.put("city", "ShanTou");
        v2.addProperty("address", address2);

        // add tags property
        List<String> tags2 = Arrays.asList("tall", "rich", "handson");
        v2.addProperty("tags", tags2);

        Edge e = new Edge("friend", v1, v2);
        e.addProperty("since", 2009);

        graph.addVertex(v1);
        graph.addVertex(v2);
        graph.addEdge(e);
    }

    @After
    public void tearDown() {
        // drop data first
        graph.dropData();
        // drop index also
        graph.dropIndex();

        graph = null;
    }

    /*
     * *****************************************************
     * 
     * Begin Query Test
     * 
     * *****************************************************
     */

    @Test
    public void testEqualitySearch() {
        long startTime = System.currentTimeMillis();
        DocumentIterator it = graph.V("Person").has("name", "argan").execute();
        System.out.println("queryTime: " + (System.currentTimeMillis() - startTime));
        try {
            while (it.hasNext()) {
                Document rec = it.next();
                System.out.println(rec);
                Assert.assertEquals("argan", rec.getProperty("name"));
            }
        } finally {
            it.close();
        }
    }

    @Test
    public void testRangeSearch() {
        long startTime = System.currentTimeMillis();
        // DocumentIterator it = graph.V("Person").has("age", Compare.GREATER_THAN, 30).execute();
        DocumentIterator it = graph.V("Person").interval("age", 30, 35).execute();
        System.out.println("queryTime: " + (System.currentTimeMillis() - startTime));
        try {
            while (it.hasNext()) {
                Document rec = it.next();
                System.out.println(rec);
                long age = (Long) rec.getProperty("age");
                Assert.assertTrue(age >= 30 && age <= 35);
            }
        } finally {
            it.close();
        }
    }

    @Test
    public void testArraySearch() {
        DocumentIterator it = graph.V("Person").has("tags", Contain.IN, "smart").execute();
        try {
            while (it.hasNext()) {
                Document rec = it.next();
                System.out.println(rec);
                List<String> tags = (List<String>) rec.getProperty("tags");
                Assert.assertTrue(tags.contains("smart"));
            }
        } finally {
            it.close();
        }
    }

    @Test
    public void testNestedIndexSearch() throws IOException {
        DocumentIterator it = graph.V("Person").has("address/city", "ShenZhen").execute();

        try {
            while (it.hasNext()) {
                Document rec = it.next();
                System.out.println(rec);
                Assert.assertEquals("ShenZhen", rec.getProperty("address/city"));
            }
        } finally {
            it.close();
        }
    }

    @Test
    public void testMultiIndexSearch() {
        /** add another vertex for test **/
        Vertex v = new Vertex("Person", "3");

        // add name property
        v.addProperty("name", "jenny");

        // add age property
        v.addProperty("age", 26);

        // add address
        Map<String, String> address = new HashMap<>();
        address.put("province", "ZJ");
        address.put("city", "HangZhou");
        v.addProperty("address", address);

        // add tags property
        List<String> tags = Arrays.asList("white", "rich", "beautiful");
        v.addProperty("tags", tags);

        graph.addVertex(v);

        DocumentIterator it =
                graph.V("Person").has("tags", Contain.IN, "rich").interval("age", 20, 30).orderBy("age", Order.DESC)
                        .vertices();
        try {
            while (it.hasNext()) {
                Document rec = it.next();
                System.out.println(rec);

                List<String> tags2 = (List<String>) rec.getProperty("tags");
                Assert.assertTrue(tags2.contains("rich"));
                long age = (Long) rec.getProperty("age");
                Assert.assertTrue(age >= 20 && age <= 30);
            }
        } finally {
            it.close();
        }
    }

    @Test
    public void testQueryEdge() throws IOException {
        DocumentIterator it = graph.E("friend").edges();
        try {
            while (it.hasNext()) {
                Document rec = it.next();
                System.out.println(rec);
            }
        } finally {
            it.close();
        }
    }

    @Test
    public void testQuery() throws IOException {
        DocumentIterator it = graph.V("Person").has("name", "argan").out("friend").interval("age", 25, 35).execute();

        try {
            while (it.hasNext()) {
                Document rec = it.next();
                System.out.println(rec);
                Assert.assertEquals("magi", rec.getProperty("name"));
            }
        } finally {
            it.close();
        }
    }
}

@Test
public void testTraversal() {
    /** find out who is god's father **/
    System.out.println("-- 1: find out who is god's father");
    long startTime = System.currentTimeMillis();
    // DocumentIterator it1 = graph.V("god").outE("father").outV().execute();
    DocumentIterator it1 = graph.V("god").out("father").execute();
    System.out.println("queryTime: " + (System.currentTimeMillis() - startTime));

    try {
        while (it1.hasNext()) {
            Document rec = it1.next();
            Assert.assertTrue(rec.getKey().equals("saturn"));
            System.out.println(rec);
        }
    } finally {
        it1.close();
    }
}

@Test
public void testTraversal2() {
    /** find out who's father is god **/
    System.out.println("-- 2: find out who's father is god");
    long startTime = System.currentTimeMillis();
    DocumentIterator it2 = graph.V("god").in("father").execute();
    System.out.println("queryTime: " + (System.currentTimeMillis() - startTime));

    try {
        while (it2.hasNext()) {
            Document rec = it2.next();
            Assert.assertTrue(rec.getKey().equals("hercules"));
            System.out.println(rec);
        }
    } finally {
        it2.close();
    }
}

@Test
public void testTraversal3() {
    /** find out who grandfather is titan. **/
    System.out.println("-- 3: find out who grandfather is titan.");
    long startTime = System.currentTimeMillis();
    DocumentIterator it3 = graph.V("titan").in("father").in("father").execute();
    System.out.println("queryTime: " + (System.currentTimeMillis() - startTime));

    try {
        while (it3.hasNext()) {
            Document rec = it3.next();
            Assert.assertTrue(rec.getKey().equals("hercules"));
            System.out.println(rec);
        }
    } finally {
        it3.close();
    }
}

@Test
public void testTraversal4() {
    /** find out who is battled with demigod for more than 1 years **/
    System.out.println("-- 4: find out who is battled with demigod for more than 1 years");
    long startTime = System.currentTimeMillis();
    DocumentIterator it4 = graph.V("demigod").outE("battled").has("time", Compare.GREATER_THAN, 1).outV().execute();
    System.out.println("queryTime: " + (System.currentTimeMillis() - startTime));
    List<String> battleds = Arrays.asList("hydra", "cerberus");
    try {
        while (it4.hasNext()) {
            Document rec = it4.next();
            Assert.assertTrue(battleds.contains(rec.getKey()));
            System.out.println(rec);
        }
    } finally {
        it4.close();
    }
}

@Test
public void testTraversal5() {
    /** find out who are pluto's cohabitants? **/
    System.out.println("-- 5: find out who are pluto's cohabitants?");
    long startTime = System.currentTimeMillis();
    // DocumentIterator it5 = graph.V("god").has("name", "pluto").out("lives").in("lives").execute();
    // pluto can't be his own cohabitant
    DocumentIterator it5 =
            graph.V("god").has("name", "pluto").out("lives").in("lives").hasNot("name", "pluto").execute();
    System.out.println("queryTime: " + (System.currentTimeMillis() - startTime));

    try {
        while (it5.hasNext()) {
            Document rec = it5.next();
            Assert.assertTrue(rec.getKey().equals("cerberus"));
            System.out.println(rec);
        }
    } finally {
        it5.close();
    }
}

@Test
public void testTraversal6() {
    /** where do pluto's brothers live? **/
    System.out.println("-- 6: where do pluto's brothers live?");
    long startTime = System.currentTimeMillis();
    DocumentIterator it6 = graph.V("god").has("name", "pluto").out("brother").out("lives").execute();
    System.out.println("queryTime: " + (System.currentTimeMillis() - startTime));

    List<String> lives = Arrays.asList("sky", "sea");
    try {
        while (it6.hasNext()) {
            Document rec = it6.next();
            Assert.assertTrue(lives.contains(rec.getKey()));
            System.out.println(rec);
        }
    } finally {
        it6.close();
    }
}