/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.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.apache.org/licenses/LICENSE-2.0
 *
 * 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 org.apache.lucene.search.spans;


import org.apache.lucene.analysis.MockAnalyzer;
import org.apache.lucene.document.Document;
import org.apache.lucene.document.Field;
import org.apache.lucene.index.IndexReader;
import org.apache.lucene.index.IndexReaderContext;
import org.apache.lucene.index.LeafReaderContext;
import org.apache.lucene.index.RandomIndexWriter;
import org.apache.lucene.index.Term;
import org.apache.lucene.search.CheckHits;
import org.apache.lucene.search.Explanation;
import org.apache.lucene.search.IndexSearcher;
import org.apache.lucene.search.ScoreMode;
import org.apache.lucene.search.Scorer;
import org.apache.lucene.search.TopDocs;
import org.apache.lucene.search.Weight;
import org.apache.lucene.store.Directory;
import org.apache.lucene.util.LuceneTestCase;

import static org.apache.lucene.search.spans.SpanTestUtil.assertFinished;
import static org.apache.lucene.search.spans.SpanTestUtil.assertNext;

public class TestNearSpansOrdered extends LuceneTestCase {
  protected IndexSearcher searcher;
  protected Directory directory;
  protected IndexReader reader;

  public static final String FIELD = "field";

  @Override
  public void tearDown() throws Exception {
    reader.close();
    directory.close();
    super.tearDown();
  }
  
  @Override
  public void setUp() throws Exception {
    super.setUp();
    directory = newDirectory();
    RandomIndexWriter writer= new RandomIndexWriter(random(), directory, newIndexWriterConfig(new MockAnalyzer(random())).setMergePolicy(newLogMergePolicy()));
    for (int i = 0; i < docFields.length; i++) {
      Document doc = new Document();
      doc.add(newTextField(FIELD, docFields[i], Field.Store.NO));
      writer.addDocument(doc);
    }
    writer.forceMerge(1);
    reader = writer.getReader();
    writer.close();
    searcher = newSearcher(getOnlyLeafReader(reader));
  }

  protected String[] docFields = {
    "w1 w2 w3 w4 w5",
    "w1 w3 w2 w3 zz",
    "w1 xx w2 yy w3",
    "w1 w3 xx w2 yy w3 zz",
    "t1 t2 t2 t1",
    "g x x g g x x x g g x x g",
      "go to webpage"
  };

  protected SpanNearQuery makeQuery(String s1, String s2, String s3,
                                    int slop, boolean inOrder) {
    return new SpanNearQuery
      (new SpanQuery[] {
        new SpanTermQuery(new Term(FIELD, s1)),
        new SpanTermQuery(new Term(FIELD, s2)),
        new SpanTermQuery(new Term(FIELD, s3)) },
       slop,
       inOrder);
  }
  protected SpanNearQuery makeQuery() {
    return makeQuery("w1","w2","w3",1,true);
  }

  protected SpanNearQuery makeOverlappedQuery(
      String sqt1, String sqt2, boolean sqOrdered,
      String t3, boolean ordered) {
    return new SpanNearQuery(
      new SpanQuery[] {
        new SpanNearQuery(new SpanQuery[] {
          new SpanTermQuery(new Term(FIELD, sqt1)),
            new SpanTermQuery(new Term(FIELD, sqt2)) },
            1,
            sqOrdered
          ),
          new SpanTermQuery(new Term(FIELD, t3)) },
          0,
          ordered);
  }
  
  public void testSpanNearQuery() throws Exception {
    SpanNearQuery q = makeQuery();
    CheckHits.checkHits(random(), q, FIELD, searcher, new int[] {0,1});
  }

  public String s(Spans span) {
    return s(span.docID(), span.startPosition(), span.endPosition());
  }
  public String s(int doc, int start, int end) {
    return "s(" + doc + "," + start + "," + end +")";
  }
  
  public void testNearSpansNext() throws Exception {
    SpanNearQuery q = makeQuery();
    Spans span = q.createWeight(searcher, ScoreMode.COMPLETE_NO_SCORES, 1f).getSpans(searcher.getIndexReader().leaves().get(0), SpanWeight.Postings.POSITIONS);
    assertNext(span,0,0,3);
    assertNext(span,1,0,4);
    assertFinished(span);
  }

  /**
   * test does not imply that skipTo(doc+1) should work exactly the
   * same as next -- it's only applicable in this case since we know doc
   * does not contain more than one span
   */
  public void testNearSpansAdvanceLikeNext() throws Exception {
    SpanNearQuery q = makeQuery();
    Spans span = q.createWeight(searcher, ScoreMode.COMPLETE_NO_SCORES, 1f).getSpans(searcher.getIndexReader().leaves().get(0), SpanWeight.Postings.POSITIONS);
    assertEquals(0, span.advance(0));
    assertEquals(0, span.nextStartPosition());
    assertEquals(s(0,0,3), s(span));
    assertEquals(1, span.advance(1));
    assertEquals(0, span.nextStartPosition());
    assertEquals(s(1,0,4), s(span));
    assertEquals(Spans.NO_MORE_DOCS, span.advance(2));
  }
  
  public void testNearSpansNextThenAdvance() throws Exception {
    SpanNearQuery q = makeQuery();
    Spans span = q.createWeight(searcher, ScoreMode.COMPLETE_NO_SCORES, 1f).getSpans(searcher.getIndexReader().leaves().get(0), SpanWeight.Postings.POSITIONS);
    assertNotSame(Spans.NO_MORE_DOCS, span.nextDoc());
    assertEquals(0, span.nextStartPosition());
    assertEquals(s(0,0,3), s(span));
    assertNotSame(Spans.NO_MORE_DOCS, span.advance(1));
    assertEquals(0, span.nextStartPosition());
    assertEquals(s(1,0,4), s(span));
    assertEquals(Spans.NO_MORE_DOCS, span.nextDoc());
  }
  
  public void testNearSpansNextThenAdvancePast() throws Exception {
    SpanNearQuery q = makeQuery();
    Spans span = q.createWeight(searcher, ScoreMode.COMPLETE_NO_SCORES, 1f).getSpans(searcher.getIndexReader().leaves().get(0), SpanWeight.Postings.POSITIONS);
    assertNotSame(Spans.NO_MORE_DOCS, span.nextDoc());
    assertEquals(0, span.nextStartPosition());
    assertEquals(s(0,0,3), s(span));
    assertEquals(Spans.NO_MORE_DOCS, span.advance(2));
  }
  
  public void testNearSpansAdvancePast() throws Exception {
    SpanNearQuery q = makeQuery();
    Spans span = q.createWeight(searcher, ScoreMode.COMPLETE_NO_SCORES, 1f).getSpans(searcher.getIndexReader().leaves().get(0), SpanWeight.Postings.POSITIONS);
    assertEquals(Spans.NO_MORE_DOCS, span.advance(2));
  }
  
  public void testNearSpansAdvanceTo0() throws Exception {
    SpanNearQuery q = makeQuery();
    Spans span = q.createWeight(searcher, ScoreMode.COMPLETE_NO_SCORES, 1f).getSpans(searcher.getIndexReader().leaves().get(0), SpanWeight.Postings.POSITIONS);
    assertEquals(0, span.advance(0));
    assertEquals(0, span.nextStartPosition());
    assertEquals(s(0,0,3), s(span));
  }

  public void testNearSpansAdvanceTo1() throws Exception {
    SpanNearQuery q = makeQuery();
    Spans span = q.createWeight(searcher, ScoreMode.COMPLETE_NO_SCORES, 1f).getSpans(searcher.getIndexReader().leaves().get(0), SpanWeight.Postings.POSITIONS);
    assertEquals(1, span.advance(1));
    assertEquals(0, span.nextStartPosition());
    assertEquals(s(1,0,4), s(span));
  }

  /**
   * not a direct test of NearSpans, but a demonstration of how/when
   * this causes problems
   */
  public void testSpanNearScorerSkipTo1() throws Exception {
    SpanNearQuery q = makeQuery();
    Weight w = searcher.createWeight(searcher.rewrite(q), ScoreMode.COMPLETE, 1);
    IndexReaderContext topReaderContext = searcher.getTopReaderContext();
    LeafReaderContext leave = topReaderContext.leaves().get(0);
    Scorer s = w.scorer(leave);
    assertEquals(1, s.iterator().advance(1));
  }

  public void testOverlappedOrderedSpan() throws Exception {
    SpanNearQuery q = makeOverlappedQuery("w5", "w3", false, "w4", true);
    CheckHits.checkHits(random(), q, FIELD, searcher, new int[] {});
  }
  
  public void testOverlappedNonOrderedSpan() throws Exception {
    SpanNearQuery q = makeOverlappedQuery("w3", "w5", true, "w4", false);
    CheckHits.checkHits(random(), q, FIELD, searcher, new int[] {0});
  }

  public void testNonOverlappedOrderedSpan() throws Exception {
    SpanNearQuery q = makeOverlappedQuery("w3", "w4", true, "w5", true);
    CheckHits.checkHits(random(), q, FIELD, searcher, new int[] {0});
  }

  public void testOrderedSpanIteration() throws Exception {
    SpanNearQuery q = new SpanNearQuery(new SpanQuery[]{
        new SpanOrQuery(new SpanTermQuery(new Term(FIELD, "w1")), new SpanTermQuery(new Term(FIELD, "w2"))),
        new SpanTermQuery(new Term(FIELD, "w4"))
    }, 10, true);
    Spans spans = q.createWeight(searcher, ScoreMode.COMPLETE_NO_SCORES, 1f).getSpans(searcher.getIndexReader().leaves().get(0), SpanWeight.Postings.POSITIONS);
    assertNext(spans,0,0,4);
    assertNext(spans,0,1,4);
    assertFinished(spans);
  }

  public void testOrderedSpanIterationSameTerms1() throws Exception {
    SpanNearQuery q = new SpanNearQuery(new SpanQuery[]{
        new SpanTermQuery(new Term(FIELD, "t1")), new SpanTermQuery(new Term(FIELD, "t2"))
    }, 1, true);
    Spans spans = q.createWeight(searcher, ScoreMode.COMPLETE_NO_SCORES, 1f).getSpans(searcher.getIndexReader().leaves().get(0), SpanWeight.Postings.POSITIONS);
    assertNext(spans,4,0,2);
    assertFinished(spans);
  }

  public void testOrderedSpanIterationSameTerms2() throws Exception {
    SpanNearQuery q = new SpanNearQuery(new SpanQuery[]{
        new SpanTermQuery(new Term(FIELD, "t2")), new SpanTermQuery(new Term(FIELD, "t1"))
    }, 1, true);
    Spans spans = q.createWeight(searcher, ScoreMode.COMPLETE_NO_SCORES, 1f).getSpans(searcher.getIndexReader().leaves().get(0), SpanWeight.Postings.POSITIONS);
    assertNext(spans,4,1,4);
    assertNext(spans,4,2,4);
    assertFinished(spans);
  }

  /**
   * not a direct test of NearSpans, but a demonstration of how/when
   * this causes problems
   */
  public void testSpanNearScorerExplain() throws Exception {
    SpanNearQuery q = makeQuery();
    Explanation e = searcher.explain(q, 1);
    assertTrue("Scorer explanation value for doc#1 isn't positive: "
               + e.toString(),
               0.0f <= e.getValue().doubleValue());
  }

  public void testGaps() throws Exception {
    SpanNearQuery q = SpanNearQuery.newOrderedNearQuery(FIELD)
        .addClause(new SpanTermQuery(new Term(FIELD, "w1")))
        .addGap(1)
        .addClause(new SpanTermQuery(new Term(FIELD, "w2")))
        .build();
    Spans spans = q.createWeight(searcher, ScoreMode.COMPLETE_NO_SCORES, 1f).getSpans(searcher.getIndexReader().leaves().get(0), SpanWeight.Postings.POSITIONS);
    assertNext(spans, 1, 0, 3);
    assertNext(spans, 2, 0, 3);
    assertFinished(spans);

    q = SpanNearQuery.newOrderedNearQuery(FIELD)
        .addClause(new SpanTermQuery(new Term(FIELD, "w1")))
        .addGap(1)
        .addClause(new SpanTermQuery(new Term(FIELD, "w2")))
        .addGap(1)
        .addClause(new SpanTermQuery(new Term(FIELD, "w3")))
        .setSlop(1)
        .build();
    spans = q.createWeight(searcher, ScoreMode.COMPLETE_NO_SCORES, 1f).getSpans(searcher.getIndexReader().leaves().get(0), SpanWeight.Postings.POSITIONS);
    assertNext(spans, 2, 0, 5);
    assertNext(spans, 3, 0, 6);
    assertFinished(spans);
  }

  public void testMultipleGaps() throws Exception {
    SpanQuery q = SpanNearQuery.newOrderedNearQuery(FIELD)
        .addClause(new SpanTermQuery(new Term(FIELD, "g")))
        .addGap(2)
        .addClause(new SpanTermQuery(new Term(FIELD, "g")))
        .build();
    Spans spans = q.createWeight(searcher, ScoreMode.COMPLETE_NO_SCORES, 1f).getSpans(searcher.getIndexReader().leaves().get(0), SpanWeight.Postings.POSITIONS);
    assertNext(spans, 5, 0, 4);
    assertNext(spans, 5, 9, 13);
    assertFinished(spans);
  }

  public void testNestedGaps() throws Exception {
    SpanQuery q = SpanNearQuery.newOrderedNearQuery(FIELD)
        .addClause(new SpanOrQuery(
            new SpanTermQuery(new Term(FIELD, "open")),
            SpanNearQuery.newOrderedNearQuery(FIELD)
                .addClause(new SpanTermQuery(new Term(FIELD, "go")))
                .addGap(1)
                .build()
        ))
        .addClause(new SpanTermQuery(new Term(FIELD, "webpage")))
        .build();

    TopDocs topDocs = searcher.search(q, 1);
    assertEquals(6, topDocs.scoreDocs[0].doc);

  }

  /*
    protected String[] docFields = {
    "w1 w2 w3 w4 w5",
    "w1 w3 w2 w3 zz",
    "w1 xx w2 yy w3",
    "w1 w3 xx w2 yy w3 zz",
    "t1 t2 t2 t1",
    "g x x g g x x x g g x x g",
    "go to webpage"
  };
   */
}