module ProMotion
  module MapScreenModule

    def screen_setup
      self.view = nil
      self.view = MKMapView.alloc.initWithFrame(self.view.bounds)
      self.view.delegate = self

      check_annotation_data
      @promotion_annotation_data = []
      set_up_start_position
    end

    def view_will_appear(animated)
      super
      update_annotation_data
    end

    def check_annotation_data
      PM.logger.error "Missing #annotation_data method in MapScreen #{self.class.to_s}." unless self.respond_to?(:annotation_data)
    end

    def update_annotation_data
      clear_annotations
      add_annotations annotation_data
    end

    def map
      self.view
    end
    alias_method :mapview, :map

    def center
      self.view.centerCoordinate
    end

    def center=(params={})
      PM.logger.error "Missing #:latitude property in call to #center=." unless params[:latitude]
      PM.logger.error "Missing #:longitude property in call to #center=." unless params[:longitude]
      params[:animated] ||= true

      # Set the new region
      self.view.setCenterCoordinate(
        CLLocationCoordinate2D.new(params[:latitude], params[:longitude]),
        animated:params[:animated]
      )
    end

    def show_user_location
      set_show_user_location true
    end

    def hide_user_location
      set_show_user_location false
    end

    def set_show_user_location(show)
      self.view.showsUserLocation = show
    end

    def showing_user_location?
      self.view.showsUserLocation
    end

    def user_location
      self.view.userLocation.location.nil? ? nil : self.view.userLocation.location.coordinate
    end

    def zoom_to_user(radius = 0.05, animated=true)
      show_user_location unless showing_user_location?
      set_region(MKCoordinateRegionMake(user_location, [radius, radius]), animated)
    end

    def annotations
      @promotion_annotation_data
    end

    def select_annotation(annotation, animated=true)
      self.view.selectAnnotation(annotation, animated:animated)
    end

    def select_annotation_at(annotation_index, animated=true)
      select_annotation(annotations[annotation_index], animated:animated)
    end

    def selected_annotations
      self.view.selectedAnnotations
    end

    def deselect_annotations(animated=false)
      unless selected_annotations.nil?
        selected_annotations.each do |annotation|
          self.view.deselectAnnotation(annotation, animated:animated)
        end
      end
    end

    def add_annotation(annotation)
      @promotion_annotation_data << MapScreenAnnotation.new(annotation)
      self.view.addAnnotation @promotion_annotation_data.last
    end

    def add_annotations(annotations)
      @promotion_annotation_data = Array(annotations).map{|a| MapScreenAnnotation.new(a)}
      self.view.addAnnotations @promotion_annotation_data
    end

    def clear_annotations
      @promotion_annotation_data.each do |a|
        self.view.removeAnnotation(a)
      end
      @promotion_annotation_data = []
    end

    def annotation_view(map_view, annotation)
      return if annotation.is_a? MKUserLocation

      params = annotation.params

      identifier = params[:identifier]
      if view = map_view.dequeueReusableAnnotationViewWithIdentifier(identifier)
        view.annotation = annotation
      else
        # Set the pin properties
        if params[:image]
          view = MKAnnotationView.alloc.initWithAnnotation(annotation, reuseIdentifier:identifier)
        else
          view = MKPinAnnotationView.alloc.initWithAnnotation(annotation, reuseIdentifier:identifier)
        end
      end
      view.image = params[:image] if view.respond_to?("image=") && params[:image]
      view.animatesDrop = params[:animates_drop] if view.respond_to?("animatesDrop=")
      view.pinColor = params[:pin_color] if view.respond_to?("pinColor=")
      view.canShowCallout = params[:show_callout] if view.respond_to?("canShowCallout=")

      if params[:left_accessory]
        view.leftCalloutAccessoryView = params[:left_accessory]
      end
      if params[:right_accessory]
        view.rightCalloutAccessoryView = params[:right_accessory]
      end

      if params[:action]
        button_type = params[:action_button_type] || UIButtonTypeDetailDisclosure

        action_button = UIButton.buttonWithType(button_type)
        action_button.addTarget(self, action: params[:action], forControlEvents:UIControlEventTouchUpInside)

        view.rightCalloutAccessoryView = action_button
      end
      view
    end

    def set_start_position(params={})
      params[:latitude] ||= 37.331789
      params[:longitude] ||= -122.029620
      params[:radius] ||= 10

      meters_per_mile = 1609.344

      initialLocation = CLLocationCoordinate2D.new(params[:latitude], params[:longitude])
      region = MKCoordinateRegionMakeWithDistance(initialLocation, params[:radius] * meters_per_mile, params[:radius] * meters_per_mile)
      set_region(region, animated:false)
    end

    def set_up_start_position
      if self.class.respond_to?(:get_start_position) && self.class.get_start_position
        self.set_start_position self.class.get_start_position_params
      end
    end

    # TODO: Why is this so complex?
    def zoom_to_fit_annotations(animated=true)
      #Don't attempt the rezoom of there are no pins
      return if annotations.count == 0

      #Set some crazy boundaries
      topLeft = CLLocationCoordinate2D.new(-90, 180)
      bottomRight = CLLocationCoordinate2D.new(90, -180)

      #Find the bounds of the pins
      annotations.each do |a|
        topLeft.longitude = [topLeft.longitude, a.coordinate.longitude].min
        topLeft.latitude = [topLeft.latitude, a.coordinate.latitude].max
        bottomRight.longitude = [bottomRight.longitude, a.coordinate.longitude].max
        bottomRight.latitude = [bottomRight.latitude, a.coordinate.latitude].min
      end

      #Find the bounds of all the pins and set the map_view
      coord = CLLocationCoordinate2D.new(
        topLeft.latitude - (topLeft.latitude - bottomRight.latitude) * 0.5,
        topLeft.longitude + (bottomRight.longitude - topLeft.longitude) * 0.5
      )

      # Add some padding to the edges
      span = MKCoordinateSpanMake(
        ((topLeft.latitude - bottomRight.latitude) * 1.075).abs,
        ((bottomRight.longitude - topLeft.longitude) * 1.075).abs
      )

      region = MKCoordinateRegionMake(coord, span)
      fits = self.view.regionThatFits(region);

      set_region(fits, animated:animated)
    end

    def set_region(region, animated=true)
      self.view.setRegion(region, animated:animated)
    end

    def region(params)
      return nil unless params.is_a? Hash

      params[:coordinate] = CLLocationCoordinate2D.new(params[:coordinate][:latitude], params[:coordinate][:longitude]) if params[:coordinate].is_a? Hash
      params[:span] = MKCoordinateSpanMake(params[:span][0], params[:span][1]) if params[:span].is_a? Array

      if params[:coordinate] && params[:span]
        MKCoordinateRegionMake( params[:coordinate], params[:span] )
      end
    end

    def look_up_address(args={}, &callback)
      args[:address] = args if args.is_a? String # Assume if a string is passed that they want an address

      geocoder = CLGeocoder.new
      return geocoder.geocodeAddressDictionary(args[:address], completionHandler: callback) if args[:address].is_a?(Hash)
      return geocoder.geocodeAddressString(args[:address].to_s, completionHandler: callback) unless args[:region]
      return geocoder.geocodeAddressString(args[:address].to_s, inRegion:args[:region].to_s, completionHandler: callback) if args[:region]
    end

    ########## Cocoa touch methods #################
    def mapView(map_view, viewForAnnotation:annotation)
      annotation_view(map_view, annotation)
    end

    def mapView(map_view, didUpdateUserLocation:userLocation)
      if self.respond_to?(:on_user_location)
        on_user_location(userLocation)
      else
        PM.logger.info "You're tracking the user's location but have not implemented the #on_user_location(location) method in MapScreen #{self.class.to_s}."
      end
    end

    ########## Cocoa touch Ruby counterparts #################

    def type
      map.mapType
    end

    def type=(type)
      map.mapType = type
    end

    %w(zoom scroll pitch rotate).each do |meth|
      define_method("#{meth}_enabled?") do
        map.send("is#{meth.capitalize}Enabled")
      end

      define_method("#{meth}_enabled=") do |argument|
        map.send("#{meth}Enabled=", argument)
      end
    end

    module MapClassMethods
      def start_position(params={})
        @start_position_params = params
        @start_position = true
      end

      def get_start_position_params
        @start_position_params ||= nil
      end

      def get_start_position
        @start_position ||= false
      end
    end
    def self.included(base)
      base.extend(MapClassMethods)
    end

  end
end