/*
 * Copyright 2008 Google Inc.
 *
 * Licensed 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 com.google.android.apps.mytracks;

import com.google.android.apps.mytracks.content.Waypoint;
import com.google.android.apps.mytracks.util.MyTracksUtils;
import com.google.android.maps.GeoPoint;
import com.google.android.maps.MapView;
import com.google.android.maps.Overlay;
import com.google.android.maps.mytracks.R;

import android.content.Context;
import android.content.Intent;
import android.graphics.Canvas;
import android.graphics.Paint;
import android.graphics.Path;
import android.graphics.Point;
import android.graphics.Rect;
import android.graphics.Region;
import android.graphics.drawable.Drawable;
import android.location.Location;

import java.util.ArrayList;

/**
 * A map overlay that displays a "MyLocation" arrow, an error circle, the
 * currently recording track and optionally a selected track.
 *
 * @author Leif Hendrik Wilden
 */
public class MyTracksOverlay extends Overlay {

  private final Drawable arrow[] = new Drawable[18];
  private final int arrowWidth, arrowHeight;
  private final Drawable statsMarker;
  private final Drawable waypointMarker;
  private final Drawable startMarker;
  private final Drawable endMarker;
  private final int markerWidth, markerHeight;
  private final Paint selectedTrackPaint;
  private final Paint errorCirclePaint;
  private final Context context;
  private final ArrayList<Waypoint> waypoints = new ArrayList<Waypoint>();
  private final ArrayList<Location> points = new ArrayList<Location>(1024);

  private boolean trackDrawingEnabled;
  private int lastHeading = 0;
  private Location myLocation;
  private boolean showEndMarker = true;
  private boolean drawBounds;

  public MyTracksOverlay(Context context) {
    this.context = context;

    // TODO: Can we use a FrameAnimation or similar here rather
    // than individual resources for each arrow direction?

    arrow[0] = context.getResources().getDrawable(R.drawable.arrow_0);
    arrow[1] = context.getResources().getDrawable(R.drawable.arrow_20);
    arrow[2] = context.getResources().getDrawable(R.drawable.arrow_40);
    arrow[3] = context.getResources().getDrawable(R.drawable.arrow_60);
    arrow[4] = context.getResources().getDrawable(R.drawable.arrow_80);
    arrow[5] = context.getResources().getDrawable(R.drawable.arrow_100);
    arrow[6] = context.getResources().getDrawable(R.drawable.arrow_120);
    arrow[7] = context.getResources().getDrawable(R.drawable.arrow_140);
    arrow[8] = context.getResources().getDrawable(R.drawable.arrow_160);
    arrow[9] = context.getResources().getDrawable(R.drawable.arrow_180);
    arrow[10] = context.getResources().getDrawable(R.drawable.arrow_200);
    arrow[11] = context.getResources().getDrawable(R.drawable.arrow_220);
    arrow[12] = context.getResources().getDrawable(R.drawable.arrow_240);
    arrow[13] = context.getResources().getDrawable(R.drawable.arrow_260);
    arrow[14] = context.getResources().getDrawable(R.drawable.arrow_280);
    arrow[15] = context.getResources().getDrawable(R.drawable.arrow_300);
    arrow[16] = context.getResources().getDrawable(R.drawable.arrow_320);
    arrow[17] = context.getResources().getDrawable(R.drawable.arrow_340);
    arrowWidth = arrow[lastHeading].getIntrinsicWidth();
    arrowHeight = arrow[lastHeading].getIntrinsicHeight();
    for (int i = 0; i <= 17; i++) {
      arrow[i].setBounds(0, 0, arrowWidth, arrowHeight);
    }

    statsMarker = context.getResources().getDrawable(R.drawable.ylw_pushpin);
    markerWidth = statsMarker.getIntrinsicWidth();
    markerHeight = statsMarker.getIntrinsicHeight();
    statsMarker.setBounds(0, 0, markerWidth, markerHeight);

    startMarker = context.getResources().getDrawable(R.drawable.green_dot);
    startMarker.setBounds(0, 0, markerWidth, markerHeight);

    endMarker = context.getResources().getDrawable(R.drawable.red_dot);
    endMarker.setBounds(0, 0, markerWidth, markerHeight);

    waypointMarker =
        context.getResources().getDrawable(R.drawable.blue_pushpin);
    waypointMarker.setBounds(0, 0, markerWidth, markerHeight);

    selectedTrackPaint = new Paint();
    selectedTrackPaint.setColor(context.getResources().getColor(R.color.red));
    selectedTrackPaint.setStrokeWidth(3);
    selectedTrackPaint.setStyle(Paint.Style.STROKE);
    selectedTrackPaint.setAntiAlias(true);

    errorCirclePaint = new Paint();
    errorCirclePaint.setColor(context.getResources().getColor(R.color.blue));
    errorCirclePaint.setStyle(Paint.Style.STROKE);
    errorCirclePaint.setStrokeWidth(3);
    errorCirclePaint.setAlpha(127);
    errorCirclePaint.setAntiAlias(true);
  }

  /**
   * Add a location to the map overlay.
   *
   * NOTE: this method takes ownership of this location and may change it.
   *
   * @param l the location to add
   */
  public void addLocation(Location l) {
    if (l != null) {
      synchronized (points) {
        points.add(l);
      }
    }
  }

  public void addWaypoint(Waypoint wpt) {
    waypoints.add(wpt);
  }

  public int getNumLocations() {
    synchronized (points) {
      return points.size();
    }
  }

  public void clearWaypoints() {
    waypoints.clear();
  }

  public void clearPoints() {
    synchronized (points) {
      points.clear();
    }
  }

  public void setTrackDrawingEnabled(boolean trackDrawingEnabled) {
    this.trackDrawingEnabled = trackDrawingEnabled;
  }

  public void setShowEndMarker(boolean showEndMarker) {
    this.showEndMarker = showEndMarker;
  }

  @Override
  public void draw(Canvas canvas, MapView mapView, boolean shadow) {
    if (shadow) {
      return;
    }

    if (trackDrawingEnabled) {
      // Draw the selected track:
      drawTrack(canvas, mapView);

      // Draw the waypoints:
      drawWaypoints(canvas, mapView);
    }

    // Draw the current location
    drawMyLocation(canvas, mapView);
  }

  private void drawWaypoints(Canvas canvas, MapView mapView) {
    ArrayList<Waypoint> currentWaypoints = waypoints;
    for (int i = 1; i < currentWaypoints.size(); i++) {
      Waypoint wpt = currentWaypoints.get(i);
      if (wpt == null) {
        continue;
      }
      Location loc = wpt.getLocation();
      if (loc == null) {
        continue;
      }
      GeoPoint geoPoint = MyTracksUtils.getGeoPoint(loc);
      Point pt = new Point();
      mapView.getProjection().toPixels(geoPoint, pt);
      canvas.save();
      canvas.translate(pt.x - (markerWidth / 2) + 3, pt.y - (markerHeight));
      if (wpt.getType() == Waypoint.TYPE_STATISTICS) {
        statsMarker.draw(canvas);
      } else {
        waypointMarker.draw(canvas);
      }
      canvas.restore();
    }
  }

  private void drawMyLocation(Canvas canvas, MapView mapView) {
    // Draw the arrow icon:
    if (myLocation == null) {
      return;
    }

    GeoPoint geoPoint = new GeoPoint(
        (int) (myLocation.getLatitude() * 1E6),
        (int) (myLocation.getLongitude() * 1E6));
    Point pt = new Point();
    mapView.getProjection().toPixels(geoPoint, pt);
    canvas.save();
    canvas.translate(pt.x - (arrowWidth / 2), pt.y - (arrowHeight / 2));
    arrow[lastHeading].draw(canvas);
    canvas.restore();

    // Draw the error circle:
    float radius =
        mapView.getProjection().metersToEquatorPixels(myLocation.getAccuracy());
    canvas.drawCircle(pt.x, pt.y, radius, errorCirclePaint);
  }

  private void drawTrack(Canvas canvas, MapView mapView) {
    Path path;
    Point pt = new Point();
    Location lastValidLocation;
    int locLon = 0, locLat = 0;
    GeoPoint firstGeoPoint = null;
    boolean lastLocValid;

    // Get the current viewing window:
    int w = mapView.getLongitudeSpan();
    int h = mapView.getLatitudeSpan();
    int cx = mapView.getMapCenter().getLongitudeE6();
    int cy = mapView.getMapCenter().getLatitudeE6();
    Rect viewRect = new Rect(cx - w, cy - h, cx + w, cy + h);

    // Global bounding box, including points not visible
    int allMinLat, allMinLon, allMaxLat, allMaxLon;
    
    synchronized (points) {
      int numPoints = points.size();
      if (numPoints < 2) {
        return;
      }

      GeoPoint geoPoint;
      Location loc;
      int minLon, maxLon, minLat, maxLat;
      lastValidLocation = points.get(0);
      int lastLocLon = allMinLon = allMaxLon = (int) (lastValidLocation.getLongitude() * 1E6);
      int lastLocLat = allMinLat = allMaxLat = (int) (lastValidLocation.getLatitude() * 1E6);
      lastLocValid = MyTracksUtils.isValidLocation(lastValidLocation);
      boolean lastLocVisible = false;
      path = new Path();

      // Loop over track points:
      path.incReserve(numPoints);
      for (int i = 1; i < numPoints; i++) {
        loc = points.get(i);

        boolean locValid = MyTracksUtils.isValidLocation(loc);
        boolean locVisible = false;
        if (locValid) {
          locLon = (int) (loc.getLongitude() * 1E6);
          locLat = (int) (loc.getLatitude() * 1E6);

          if (firstGeoPoint == null) {
            // Found the starting point
            firstGeoPoint = new GeoPoint(locLat, locLon);
          }

          // If both the current and previous locations were valid
          if (lastLocValid) {
            lastValidLocation = loc;
  
            // Get the bounding box of the segment about to be drawn
            if (locLon > lastLocLon) {
              minLon = lastLocLon;
              maxLon = locLon;
            } else {
              minLon = locLon;
              maxLon = lastLocLon;
            }
            if (locLat > lastLocLat) {
              minLat = lastLocLat;
              maxLat = locLat;
            } else {
              minLat = locLat;
              maxLat = lastLocLat;
            }

            if (drawBounds) {
              allMaxLat = Math.max(allMaxLat, maxLat);
              allMinLat = Math.min(allMinLat, minLat);
              allMaxLon = Math.max(allMaxLon, maxLon);
              allMinLon = Math.min(allMinLon, minLon);
            }

            // See if that bounding box intersects the viewable bounding box
            // Assume that if it does, the location is visible
            locVisible = viewRect.intersects(minLon, minLat, maxLon, maxLat);
            if (locVisible) {
              // If the previous point wasn't drawn, start at its position
              if (!lastLocVisible) {
                geoPoint = new GeoPoint(lastLocLat, lastLocLon);
                mapView.getProjection().toPixels(geoPoint, pt);
                path.moveTo(pt.x, pt.y);
              }
  
              // Draw a line to the new point
              geoPoint = new GeoPoint(locLat, locLon);
              mapView.getProjection().toPixels(geoPoint, pt);
              path.lineTo(pt.x, pt.y);
            }
          }
        }
        lastLocLon = locLon;
        lastLocLat = locLat;
        lastLocValid = locValid;
        lastLocVisible = locVisible;
      }
    }

    canvas.drawPath(path, selectedTrackPaint);

    if (drawBounds) {
      drawBoundingBox(canvas, mapView,
          allMinLat, allMinLon, allMaxLat, allMaxLon);
    }

    // Draw the "End" marker:
    if (showEndMarker && lastValidLocation != null) {
      canvas.save();
      GeoPoint geoPoint = MyTracksUtils.getGeoPoint(lastValidLocation);
      mapView.getProjection().toPixels(geoPoint, pt);
      canvas.translate(pt.x - (markerWidth / 2), pt.y - markerHeight);
      endMarker.draw(canvas);
      canvas.restore();
    }

    // Draw the "Start" marker:
    if (firstGeoPoint != null) {
      mapView.getProjection().toPixels(firstGeoPoint, pt);
      canvas.save();
      canvas.translate(pt.x - (markerWidth / 2), pt.y - markerHeight);
      startMarker.draw(canvas);
      canvas.restore();
    }
  }

  private void drawBoundingBox(Canvas canvas, MapView mapView, int allMinLat,
      int allMinLon, int allMaxLat, int allMaxLon) {
    // Transform coordinates
    GeoPoint maxPoint = new GeoPoint(allMaxLat, allMaxLon);
    GeoPoint minPoint = new GeoPoint(allMinLat, allMinLon);
    Point minPt = new Point();
    Point maxPt = new Point();
    mapView.getProjection().toPixels(minPoint, minPt);
    mapView.getProjection().toPixels(maxPoint, maxPt);
    Rect allBounds = new Rect(minPt.x, minPt.y, maxPt.x, maxPt.y);

    // Prepare a green paint
    Paint boundingBoxPaint = new Paint();
    boundingBoxPaint.setColor(context.getResources().getColor(R.color.green));
    boundingBoxPaint.setStrokeWidth(2);
    boundingBoxPaint.setStyle(Paint.Style.STROKE);
    boundingBoxPaint.setAntiAlias(true);

    // Disable clipping
    canvas.save();
    canvas.clipRect(Float.NEGATIVE_INFINITY, Float.NEGATIVE_INFINITY,
                    Float.POSITIVE_INFINITY, Float.POSITIVE_INFINITY,
                    Region.Op.REPLACE);

    // Draw the bounding box
    canvas.drawRect(allBounds, boundingBoxPaint);

    // Re-enable clipping
    canvas.restore();
  }

  @Override
  public boolean draw(Canvas canvas, MapView mapView, boolean shadow,
      long when) {
    draw(canvas, mapView, shadow);
    return false;
  }

  /**
   * Sets the pointer location (will be drawn on next invalidate).
   */
  public void setMyLocation(Location myLocation) {
    this.myLocation = myLocation;
  }

  /**
   * Sets the pointer heading in degrees (will be drawn on next invalidate).
   *
   * @return true if the visible heading changed (i.e. a redraw of pointer is
   *         potentially necessary)
   */
  public boolean setHeading(float heading) {
    int newhdg = Math.round(-heading / 360 * 18 + 180);
    while (newhdg < 0)
      newhdg += 18;
    while (newhdg > 17)
      newhdg -= 18;
    if (newhdg != lastHeading) {
      lastHeading = newhdg;
      return true;
    } else {
      return false;
    }
  }

  @Override
  public boolean onTap(GeoPoint p, MapView mapView) {
    if (p.equals(mapView.getMapCenter())) {
      // There is (unfortunately) no good way to determine whether the tap was
      // caused by an actual tap on the screen or the track ball. If the
      // location is equal to the map center,then it was a track ball press with
      // very high likelihood.
      return false;
    }

    final Location tapLocation = MyTracksUtils.getLocation(p);
    double dmin = Double.MAX_VALUE;
    Waypoint waypoint = null;
    for (int i = 0; i < waypoints.size(); i++) {
      final Location waypointLocation = waypoints.get(i).getLocation();
      if (waypointLocation == null) {
        continue;
      }
      final double d = waypointLocation.distanceTo(tapLocation);
      if (d < dmin) {
        dmin = d;
        waypoint = waypoints.get(i);
      }
    }

    if (waypoint != null
        && dmin < 15000000 / Math.pow(2, mapView.getZoomLevel())) {
      Intent intent = new Intent(context, MyTracksWaypointDetails.class);
      intent.putExtra("waypointid", waypoint.getId());
      context.startActivity(intent);
      return true;
    }
    return super.onTap(p, mapView);
  }

  public void setDrawBounds(boolean drawBounds) {
    this.drawBounds = drawBounds;
  }
}