/**
 * 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.spatial.tier;

import java.io.IOException;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;

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.IndexWriter;
import org.apache.lucene.index.IndexReader;
import org.apache.lucene.index.Term;
import org.apache.lucene.search.IndexSearcher;
import org.apache.lucene.search.Query;
import org.apache.lucene.search.ScoreDoc;
import org.apache.lucene.search.Sort;
import org.apache.lucene.search.SortField;
import org.apache.lucene.search.TermQuery;
import org.apache.lucene.search.TopDocs;
import org.apache.lucene.search.function.CustomScoreQuery;
import org.apache.lucene.search.function.CustomScoreProvider;
import org.apache.lucene.search.function.FieldScoreQuery;
import org.apache.lucene.search.function.FieldScoreQuery.Type;
import org.apache.lucene.spatial.DistanceUtils;
import org.apache.lucene.spatial.geohash.GeoHashUtils;
import org.apache.lucene.spatial.geometry.DistanceUnits;
import org.apache.lucene.spatial.geometry.FloatLatLng;
import org.apache.lucene.spatial.geometry.LatLng;
import org.apache.lucene.spatial.tier.projections.CartesianTierPlotter;
import org.apache.lucene.spatial.tier.projections.IProjector;
import org.apache.lucene.spatial.tier.projections.SinusoidalProjector;
import org.apache.lucene.store.Directory;
import org.apache.lucene.util.LuceneTestCase;
import org.apache.lucene.util.NumericUtils;

public class TestCartesian extends LuceneTestCase {

  private Directory directory;
  private IndexSearcher searcher;
  // reston va
  private double lat = 38.969398; 
  private double lng= -77.386398;
  private String latField = "lat";
  private String lngField = "lng";
  private List<CartesianTierPlotter> ctps = new LinkedList<CartesianTierPlotter>();
  private String geoHashPrefix = "_geoHash_";
  
  private IProjector project = new SinusoidalProjector();
  


  @Override
  public void setUp() throws Exception {
    super.setUp();
    directory = newDirectory();

    IndexWriter writer = new IndexWriter(directory, newIndexWriterConfig(TEST_VERSION_CURRENT, new MockAnalyzer(random)));
    
    setUpPlotter( 2, 15);
    
    addData(writer);
    
  }
  
  @Override
  public void tearDown() throws Exception {
    directory.close();
    super.tearDown();
  }
  
  
  private void setUpPlotter(int base, int top) {
    
    for (; base <= top; base ++){
      ctps.add(new CartesianTierPlotter(base,project,
          CartesianTierPlotter.DEFALT_FIELD_PREFIX));
    }
  }
  
  private void addPoint(IndexWriter writer, String name, double lat, double lng) throws IOException{
    
    Document doc = new Document();
    
    doc.add(newField("name", name,Field.Store.YES, Field.Index.ANALYZED));
    
    // convert the lat / long to lucene fields
    doc.add(new Field(latField, NumericUtils.doubleToPrefixCoded(lat),Field.Store.YES, Field.Index.NOT_ANALYZED));
    doc.add(new Field(lngField, NumericUtils.doubleToPrefixCoded(lng),Field.Store.YES, Field.Index.NOT_ANALYZED));
    
    // add a default meta field to make searching all documents easy 
    doc.add(newField("metafile", "doc",Field.Store.YES, Field.Index.ANALYZED));
    
    int ctpsize = ctps.size();
    for (int i =0; i < ctpsize; i++){
      CartesianTierPlotter ctp = ctps.get(i);
      doc.add(new Field(ctp.getTierFieldName(), 
          NumericUtils.doubleToPrefixCoded(ctp.getTierBoxId(lat,lng)),
          Field.Store.YES, 
          Field.Index.NOT_ANALYZED_NO_NORMS));
      
      doc.add(newField(geoHashPrefix, GeoHashUtils.encode(lat,lng), 
    		  Field.Store.YES, 
    		  Field.Index.NOT_ANALYZED_NO_NORMS));
    }
    writer.addDocument(doc);
    
  }
  
  
  
  private void addData(IndexWriter writer) throws IOException {
    addPoint(writer,"McCormick &amp; Schmick's Seafood Restaurant",38.9579000,-77.3572000);
    addPoint(writer,"Jimmy's Old Town Tavern",38.9690000,-77.3862000);
    addPoint(writer,"Ned Devine's",38.9510000,-77.4107000);
    addPoint(writer,"Old Brogue Irish Pub",38.9955000,-77.2884000);
    addPoint(writer,"Alf Laylah Wa Laylah",38.8956000,-77.4258000);
    addPoint(writer,"Sully's Restaurant &amp; Supper",38.9003000,-77.4467000);
    addPoint(writer,"TGIFriday",38.8725000,-77.3829000);
    addPoint(writer,"Potomac Swing Dance Club",38.9027000,-77.2639000);
    addPoint(writer,"White Tiger Restaurant",38.9027000,-77.2638000);
    addPoint(writer,"Jammin' Java",38.9039000,-77.2622000);
    addPoint(writer,"Potomac Swing Dance Club",38.9027000,-77.2639000);
    addPoint(writer,"WiseAcres Comedy Club",38.9248000,-77.2344000);
    addPoint(writer,"Glen Echo Spanish Ballroom",38.9691000,-77.1400000);
    addPoint(writer,"Whitlow's on Wilson",38.8889000,-77.0926000);
    addPoint(writer,"Iota Club and Cafe",38.8890000,-77.0923000);
    addPoint(writer,"Hilton Washington Embassy Row",38.9103000,-77.0451000);
    addPoint(writer,"HorseFeathers, Bar & Grill", 39.01220000000001, -77.3942);
    addPoint(writer,"Marshall Island Airfield",7.06, 171.2);
    addPoint(writer, "Wonga Wongue Reserve, Gabon", -0.546562,9.459229);
    addPoint(writer,"Midway Island",25.7, -171.7);
    addPoint(writer,"North Pole Way",55.0, 4.0);
   
    writer.commit();
    // TODO: fix CustomScoreQuery usage in testRange/testGeoHashRange so we don't need this.
    writer.forceMerge(1);
    writer.close();
  }


  public void testDistances() throws IOException, InvalidGeoException {
    LatLng p1 = new FloatLatLng( 7.06, 171.2 );
    LatLng p2 = new FloatLatLng( 21.6032207, -158.0 );
    double miles = p1.arcDistance( p2, DistanceUnits.MILES );
    if (VERBOSE) {
      System.out.println("testDistances");
      System.out.println("miles:" + miles);
    }
    assertEquals(2288.82495932794, miles, 0.001);
    LatLng p3 = new FloatLatLng( 41.6032207, -73.087749);
    LatLng p4 = new FloatLatLng( 55.0, 4.0 );
    miles = p3.arcDistance( p4, DistanceUnits.MILES );
    if (VERBOSE) System.out.println("miles:" + miles);
    assertEquals(3474.331719997617, miles, 0.001);
  }

  /*public void testCartesianPolyFilterBuilder() throws Exception {
    CartesianPolyFilterBuilder cpfb = new CartesianPolyFilterBuilder(CartesianTierPlotter.DEFALT_FIELD_PREFIX, 2, 15);
    //try out some shapes
    final double miles = 20.0;
        // Hawaii
        // 2300 miles to Marshall Island Airfield
    //Hawaii to Midway is 911 miles
    lat = 0;
    lng = -179.9;
    Shape shape;
    shape = cpfb.getBoxShape(lat, lng, miles);
    System.out.println("Tier: " + shape.getTierLevel());
    System.out.println("area: " + shape.getArea().size());
    lat = 30;
    lng = -100;
    shape = cpfb.getBoxShape(lat, lng, miles);
    System.out.println("Tier: " + shape.getTierLevel());
    System.out.println("area: " + shape.getArea().size());

    lat = 30;
    lng = 100;
    shape = cpfb.getBoxShape(lat, lng, miles);
    System.out.println("Tier: " + shape.getTierLevel());
    System.out.println("area: " + shape.getArea().size());
  }
*/


  public void testAntiM() throws IOException, InvalidGeoException {
    IndexReader reader = IndexReader.open(directory);
    searcher = new IndexSearcher(reader);

    final double miles = 2800.0;
        // Hawaii
        // 2300 miles to Marshall Island Airfield
    //Hawaii to Midway is 911 miles
    lat = 21.6032207;
    lng = -158.0;

    if (VERBOSE) System.out.println("testAntiM");
    // create a distance query
    final DistanceQueryBuilder dq = new DistanceQueryBuilder(lat, lng, miles,
        latField, lngField, CartesianTierPlotter.DEFALT_FIELD_PREFIX, true, 2, 15);

    if (VERBOSE) System.out.println(dq);
    //create a term query to search against all documents
    Query tq = new TermQuery(new Term("metafile", "doc"));

    FieldScoreQuery fsQuery = new FieldScoreQuery("geo_distance", Type.FLOAT);

    CustomScoreQuery customScore = new CustomScoreQuery(dq.getQuery(tq),fsQuery){

      @Override
      protected CustomScoreProvider getCustomScoreProvider(IndexReader reader) {
        return new CustomScoreProvider(reader) {
          @Override // TODO: broken, as reader is not used!
          public float customScore(int doc, float subQueryScore, float valSrcScore){
            if (VERBOSE) System.out.println(doc);
            if (dq.distanceFilter.getDistance(doc) == null)
              return 0;

            double distance = dq.distanceFilter.getDistance(doc);
            // boost score shouldn't exceed 1
            if (distance < 1.0d)
              distance = 1.0d;
            //boost by distance is invertly proportional to
            // to distance from center point to location
            float score = (float) ((miles - distance) / miles );
            return score * subQueryScore;
          }
        };
      }
      
    };
    // Create a distance sort
    // As the radius filter has performed the distance calculations
    // already, pass in the filter to reuse the results.
    //
    DistanceFieldComparatorSource dsort = new DistanceFieldComparatorSource(dq.distanceFilter);
    Sort sort = new Sort(new SortField("foo", dsort,false));

    // Perform the search, using the term query, the serial chain filter, and the
    // distance sort
    TopDocs hits = searcher.search(customScore.createWeight(searcher),null, 1000, sort);
    int results = hits.totalHits;
    ScoreDoc[] scoreDocs = hits.scoreDocs; 
    
    // Get a list of distances
    Map<Integer,Double> distances = dq.distanceFilter.getDistances();

    // distances calculated from filter first pass must be less than total
    // docs, from the above test of 20 items, 12 will come from the boundary box
    // filter, but only 5 are actually in the radius of the results.

    // Note Boundary Box filtering, is not accurate enough for most systems.


    if (VERBOSE) {
      System.out.println("Distance Filter filtered: " + distances.size());
      System.out.println("Results: " + results);
      System.out.println("=============================");
      System.out.println("Distances should be 2 "+ distances.size());
      System.out.println("Results should be 2 "+ results);
    }

    assertEquals(2, distances.size()); // fixed a store of only needed distances
    assertEquals(2, results);
    double lastDistance = 0;
    for(int i =0 ; i < results; i++){
      Document d = searcher.doc(scoreDocs[i].doc);

      String name = d.get("name");
      double rsLat = NumericUtils.prefixCodedToDouble(d.get(latField));
      double rsLng = NumericUtils.prefixCodedToDouble(d.get(lngField));
      Double geo_distance = distances.get(scoreDocs[i].doc);

      double distance = DistanceUtils.getDistanceMi(lat, lng, rsLat, rsLng);
      double llm = DistanceUtils.getLLMDistance(lat, lng, rsLat, rsLng);
      if (VERBOSE) System.out.println("Name: "+ name +", Distance "+ distance); //(res, ortho, harvesine):"+ distance +" |"+ geo_distance +"|"+ llm +" | score "+ hits.score(i));
      assertTrue(Math.abs((distance - llm)) < 1);
      assertTrue((distance < miles ));
      assertTrue(geo_distance >= lastDistance);
      lastDistance = geo_distance;
    }
    searcher.close();
    reader.close();
  }

  public void testPoleFlipping() throws IOException, InvalidGeoException {
    IndexReader reader = IndexReader.open(directory);
    searcher = new IndexSearcher(reader);

    final double miles = 3500.0;
    lat = 41.6032207;
    lng = -73.087749;

    if (VERBOSE) System.out.println("testPoleFlipping");

    // create a distance query
    final DistanceQueryBuilder dq = new DistanceQueryBuilder(lat, lng, miles,
        latField, lngField, CartesianTierPlotter.DEFALT_FIELD_PREFIX, true, 2, 15);

    if (VERBOSE) System.out.println(dq);
    //create a term query to search against all documents
    Query tq = new TermQuery(new Term("metafile", "doc"));

    FieldScoreQuery fsQuery = new FieldScoreQuery("geo_distance", Type.FLOAT);

    CustomScoreQuery customScore = new CustomScoreQuery(dq.getQuery(tq),fsQuery){

      @Override
      protected CustomScoreProvider getCustomScoreProvider(IndexReader reader) {
        return new CustomScoreProvider(reader) {
          @Override // TODO: broken, as reader is not used!
          public float customScore(int doc, float subQueryScore, float valSrcScore){
            if (VERBOSE) System.out.println(doc);
            if (dq.distanceFilter.getDistance(doc) == null)
              return 0;

            double distance = dq.distanceFilter.getDistance(doc);
            // boost score shouldn't exceed 1
            if (distance < 1.0d)
              distance = 1.0d;
            //boost by distance is invertly proportional to
            // to distance from center point to location
            float score = (float) ((miles - distance) / miles );
            return score * subQueryScore;
          }
        };
      }
      
    };
    // Create a distance sort
    // As the radius filter has performed the distance calculations
    // already, pass in the filter to reuse the results.
    //
    DistanceFieldComparatorSource dsort = new DistanceFieldComparatorSource(dq.distanceFilter);
    Sort sort = new Sort(new SortField("foo", dsort,false));

    // Perform the search, using the term query, the serial chain filter, and the
    // distance sort
    TopDocs hits = searcher.search(customScore.createWeight(searcher),null, 1000, sort);
    int results = hits.totalHits;
    ScoreDoc[] scoreDocs = hits.scoreDocs; 

    // Get a list of distances
    Map<Integer,Double> distances = dq.distanceFilter.getDistances();

    // distances calculated from filter first pass must be less than total
    // docs, from the above test of 20 items, 12 will come from the boundary box
    // filter, but only 5 are actually in the radius of the results.

    // Note Boundary Box filtering, is not accurate enough for most systems.


    if (VERBOSE) {
      System.out.println("Distance Filter filtered: " + distances.size());
      System.out.println("Results: " + results);
      System.out.println("=============================");
      System.out.println("Distances should be 18 "+ distances.size());
      System.out.println("Results should be 18 "+ results);
    }

    assertEquals(18, distances.size()); // fixed a store of only needed distances
    assertEquals(18, results);
    double lastDistance = 0;
    for(int i =0 ; i < results; i++){
      Document d = searcher.doc(scoreDocs[i].doc);
      String name = d.get("name");
      double rsLat = NumericUtils.prefixCodedToDouble(d.get(latField));
      double rsLng = NumericUtils.prefixCodedToDouble(d.get(lngField));
      Double geo_distance = distances.get(scoreDocs[i].doc);

      double distance = DistanceUtils.getDistanceMi(lat, lng, rsLat, rsLng);
      double llm = DistanceUtils.getLLMDistance(lat, lng, rsLat, rsLng);
      if (VERBOSE) System.out.println("Name: "+ name +", Distance "+ distance); //(res, ortho, harvesine):"+ distance +" |"+ geo_distance +"|"+ llm +" | score "+ hits.score(i));
      assertTrue(Math.abs((distance - llm)) < 1);
      if (VERBOSE) System.out.println("checking limit "+ distance + " < " + miles);
      assertTrue((distance < miles ));
      if (VERBOSE) System.out.println("checking sort "+ geo_distance + " >= " + lastDistance);
      assertTrue(geo_distance >= lastDistance);
      lastDistance = geo_distance;
    }
    searcher.close();
    reader.close();
  }
  
  public void testRange() throws IOException, InvalidGeoException {
    IndexReader reader = IndexReader.open(directory);
    searcher = new IndexSearcher(reader);

    final double[] milesToTest = new double[] {6.0, 0.5, 0.001, 0.0};
    final int[] expected = new int[] {7, 1, 0, 0};

    for(int x=0;x<expected.length;x++) {
    
      final double miles = milesToTest[x];
    
      // create a distance query
      final DistanceQueryBuilder dq = new DistanceQueryBuilder(lat, lng, miles, 
                                                               latField, lngField, CartesianTierPlotter.DEFALT_FIELD_PREFIX, true, 2, 15);
     
      if (VERBOSE) System.out.println(dq);
      //create a term query to search against all documents
      Query tq = new TermQuery(new Term("metafile", "doc"));
    
      FieldScoreQuery fsQuery = new FieldScoreQuery("geo_distance", Type.FLOAT);
    
      CustomScoreQuery customScore = new CustomScoreQuery(dq.getQuery(tq),fsQuery){
        @Override
        protected CustomScoreProvider getCustomScoreProvider(IndexReader reader) {
          return new CustomScoreProvider(reader) {
            @Override // TODO: broken, as reader is not used!
            public float customScore(int doc, float subQueryScore, float valSrcScore){
              if (VERBOSE) System.out.println(doc);
              if (dq.distanceFilter.getDistance(doc) == null)
                return 0;
          
              double distance = dq.distanceFilter.getDistance(doc);
              // boost score shouldn't exceed 1
              if (distance < 1.0d)
                distance = 1.0d;
              //boost by distance is invertly proportional to
              // to distance from center point to location
              float score = (float) ( (miles - distance) / miles );
              return score * subQueryScore;
            }
          };
        }
      };
      // Create a distance sort
      // As the radius filter has performed the distance calculations
      // already, pass in the filter to reuse the results.
      // 
      DistanceFieldComparatorSource dsort = new DistanceFieldComparatorSource(dq.distanceFilter);
      Sort sort = new Sort(new SortField("foo", dsort,false));
    
      // Perform the search, using the term query, the serial chain filter, and the
      // distance sort
      TopDocs hits = searcher.search(customScore.createWeight(searcher),null, 1000, sort);
      int results = hits.totalHits;
      ScoreDoc[] scoreDocs = hits.scoreDocs; 
    
      // Get a list of distances 
      Map<Integer,Double> distances = dq.distanceFilter.getDistances();
    
      // distances calculated from filter first pass must be less than total
      // docs, from the above test of 20 items, 12 will come from the boundary box
      // filter, but only 5 are actually in the radius of the results.
    
      // Note Boundary Box filtering, is not accurate enough for most systems.
    
      if (VERBOSE) {
        System.out.println("Distance Filter filtered: " + distances.size());
        System.out.println("Results: " + results);
        System.out.println("=============================");
        System.out.println("Distances should be 7 "+ expected[x] + ":" + distances.size());
        System.out.println("Results should be 7 "+ expected[x] + ":" + results);
      }

      assertEquals(expected[x], distances.size()); // fixed a store of only needed distances
      assertEquals(expected[x], results);
      double lastDistance = 0;
      for(int i =0 ; i < results; i++){
        Document d = searcher.doc(scoreDocs[i].doc);
      
        String name = d.get("name");
        double rsLat = NumericUtils.prefixCodedToDouble(d.get(latField));
        double rsLng = NumericUtils.prefixCodedToDouble(d.get(lngField)); 
        Double geo_distance = distances.get(scoreDocs[i].doc);
      
        double distance = DistanceUtils.getDistanceMi(lat, lng, rsLat, rsLng);
        double llm = DistanceUtils.getLLMDistance(lat, lng, rsLat, rsLng);
        if (VERBOSE) System.out.println("Name: "+ name +", Distance "+ distance); //(res, ortho, harvesine):"+ distance +" |"+ geo_distance +"|"+ llm +" | score "+ hits.score(i));
        assertTrue(Math.abs((distance - llm)) < 1);
        assertTrue((distance < miles ));
        assertTrue(geo_distance > lastDistance);
        lastDistance = geo_distance;
      }
    }
    searcher.close();
    reader.close();
  }
  
  
  
  public void testGeoHashRange() throws IOException, InvalidGeoException {
    IndexReader reader = IndexReader.open(directory);
    searcher = new IndexSearcher(reader);
	    
    final double[] milesToTest = new double[] {6.0, 0.5, 0.001, 0.0};
    final int[] expected = new int[] {7, 1, 0, 0};

    for(int x=0;x<expected.length;x++) {
      final double miles = milesToTest[x];
	    
      // create a distance query
      final DistanceQueryBuilder dq = new DistanceQueryBuilder(lat, lng, miles, 
                                                               geoHashPrefix, CartesianTierPlotter.DEFALT_FIELD_PREFIX, true, 2, 15);
	     
      if (VERBOSE) System.out.println(dq);
      //create a term query to search against all documents
      Query tq = new TermQuery(new Term("metafile", "doc"));
	    
      FieldScoreQuery fsQuery = new FieldScoreQuery("geo_distance", Type.FLOAT);
      CustomScoreQuery customScore = new CustomScoreQuery(tq,fsQuery){
        @Override
        protected CustomScoreProvider getCustomScoreProvider(IndexReader reader) {
          return new CustomScoreProvider(reader) {
              @Override // TODO: broken, as reader is not used!
              public float customScore(int doc, float subQueryScore, float valSrcScore){
              if (VERBOSE) System.out.println(doc);
              if (dq.distanceFilter.getDistance(doc) == null)
                return 0;
            
              double distance = dq.distanceFilter.getDistance(doc);
              // boost score shouldn't exceed 1
              if (distance < 1.0d)
                distance = 1.0d;
              //boost by distance is invertly proportional to
              // to distance from center point to location
              float score = (float) ( (miles - distance) / miles );
              return score * subQueryScore;
            }
          };
        }
      };
      // Create a distance sort
      // As the radius filter has performed the distance calculations
      // already, pass in the filter to reuse the results.
      // 
      //DistanceFieldComparatorSource dsort = new DistanceFieldComparatorSource(dq.distanceFilter);
      //Sort sort = new Sort(new SortField("foo", dsort));
	    
      // Perform the search, using the term query, the serial chain filter, and the
      // distance sort
      TopDocs hits = searcher.search(customScore.createWeight(searcher),dq.getFilter(), 1000); //,sort);
      int results = hits.totalHits;
      ScoreDoc[] scoreDocs = hits.scoreDocs; 
	    
      // Get a list of distances 
      Map<Integer,Double> distances = dq.distanceFilter.getDistances();
	    
      // distances calculated from filter first pass must be less than total
      // docs, from the above test of 20 items, 12 will come from the boundary box
      // filter, but only 5 are actually in the radius of the results.
	    
      // Note Boundary Box filtering, is not accurate enough for most systems.
	    
	    if (VERBOSE) {
        System.out.println("Distance Filter filtered: " + distances.size());
        System.out.println("Results: " + results);
        System.out.println("=============================");
        System.out.println("Distances should be 14 "+ expected[x] + ":" + distances.size());
        System.out.println("Results should be 7 "+ expected[x] + ":" + results);
      }

      assertEquals(expected[x], distances.size());
      assertEquals(expected[x], results);
	    
      for(int i =0 ; i < results; i++){
        Document d = searcher.doc(scoreDocs[i].doc);
	      
        String name = d.get("name");
        double rsLat = NumericUtils.prefixCodedToDouble(d.get(latField));
        double rsLng = NumericUtils.prefixCodedToDouble(d.get(lngField)); 
        Double geo_distance = distances.get(scoreDocs[i].doc);
	      
        double distance = DistanceUtils.getDistanceMi(lat, lng, rsLat, rsLng);
        double llm = DistanceUtils.getLLMDistance(lat, lng, rsLat, rsLng);
        if (VERBOSE) System.out.println("Name: "+ name +", Distance (res, ortho, harvesine):"+ distance +" |"+ geo_distance +"|"+ llm +" | score "+ scoreDocs[i].score);
        assertTrue(Math.abs((distance - llm)) < 1);
        assertTrue((distance < miles ));
	      
      }
    }
    searcher.close();
    reader.close();
  }
}
