class Pact::Consumer::AppManager

def app_registered_on?(port)

def app_registered_on?(port)
  app_registrations.any? { |app_registration| app_registration.port == port }
end

def app_registrations

def app_registrations
  @app_registrations
end

def clear_all

def clear_all
  kill_all
  @app_registrations = []
end

def create_log_file service_name

def create_log_file service_name
  FileUtils::mkdir_p Pact.configuration.log_dir
  log = File.open(log_file_path(service_name), 'w')
  log.sync = true
  log
end

def existing_app_on_port port

def existing_app_on_port port
  app_registration = @app_registrations.find { |app_registration| app_registration.port == port }
  app_registration ? app_registration.app : nil
end

def initialize

def initialize
  @apps_spawned = false
  @app_registrations = []
end

def kill_all

def kill_all
  app_registrations.find_all(&:spawned?).collect(&:kill)
  @apps_spawned = false
end

def log_file_name service_name

def log_file_name service_name
  lower_case_name = service_name.downcase.gsub(/\s+/, '_')
  if lower_case_name.include?('_service')
    lower_case_name.gsub('_service', '_mock_service')
  else
    lower_case_name + '_mock_service'
  end        
end

def log_file_path service_name

def log_file_path service_name
  File.join(Pact.configuration.log_dir, "#{log_file_name(service_name)}.log")
end

def ports_of_mock_services

def ports_of_mock_services
  app_registrations.find_all(&:is_a_mock_service?).collect(&:port)
end

def register(app, port = FindAPort.available_port)

def register(app, port = FindAPort.available_port)
  existing = existing_app_on_port port
  raise "Port #{port} is already being used by #{existing}" if existing and not existing == app
  app_registration = register_app app, port
  app_registration.spawn if @apps_spawned
  port
end

def register_app app, port

def register_app app, port
  app_registration = AppRegistration.new :app => app, :port => port
  app_registrations << app_registration
  app_registration
end

def register_mock_service_for name, url

def register_mock_service_for name, url
  uri = URI(url)
  raise "Currently only http is supported" unless uri.scheme == 'http'
  raise "Currently only services on localhost are supported" unless uri.host == 'localhost'
  register(MockService.new(log_file: create_log_file(name), name: name), uri.port)
end

def spawn_all

def spawn_all
  app_registrations.find_all(&:not_spawned?).collect(&:spawn)
  @apps_spawned = true
end