module Convox
  module Api
    class Client
      include HTTMultiParty
      debug_output $stdout
      format :json
      base_uri 'https://console.convox.com'
      
      def initialize(api_key)
        raise 'api_key must be set' if api_key.nil?
        @api_key = api_key
      end
            
      def apps(rack: nil)
        query = {}
        query[:rack] = rack if rack
        parsed_response!(self.class.get('/apps', query: query, headers: authorization_headers))
      end
      
      def create_app(name, rack: nil)
        query = {name: name}
        query[:rack] = rack if rack
        parsed_response!(self.class.post('/apps', query: query, headers: authorization_headers))
      end
      
      def delete_app(name, rack: nil)
        query = {}
        query[:rack] = rack if rack
        parsed_response!(self.class.delete("/apps/#{name}", query: query, headers: authorization_headers))
      end
      
      def app(app, rack: nil)
        query = {}
        query[:rack] = rack if rack
        parsed_response!(self.class.get("/apps/#{app}", query: query, headers: authorization_headers))
      end
      
      def app_builds(app, rack: nil)
        query = {}
        query[:rack] = rack if rack
        parsed_response!(self.class.get("/apps/#{app}/builds", query: query, headers: authorization_headers))
      end
      
      def create_app_build(app, rack: nil, cache: nil, description: nil, manifest: 'docker-compose.yml', repo: nil, source: nil)
        query = {}
        query[:rack] = rack if rack
        query[:cache] = cache if cache
        query[:description] = description if description
        query[:manifest] = manifest if manifest
        query[:repo] = repo if repo
        query[:source] = source if source
        
        parsed_response!(self.class.post("/apps/#{app}/builds", query: query, headers: authorization_headers))
      end
      
      # API not functioning
      def delete_app_build(app, build, rack: nil)
        query = {}
        query[:rack] = rack if rack
        parsed_response!(self.class.delete("/apps/#{app}/builds/#{build}", query: query, headers: authorization_headers))
      end
      
      # API not functioning
      def app_build(app, build, rack: nil)
        query = {}
        query[:rack] = rack if rack
        parsed_response!(self.class.delete("/apps/#{app}/builds/#{build}", query: query, headers: authorization_headers))
      end
      
      def update_app_build(app, build, rack: nil)
        raise 'Not implemented'
      end
      
      def app_environment(app, rack: nil)
        query = {}
        query[:rack] = rack if rack
        parsed_response!(self.class.get("/apps/#{app}/environment", query: query, headers: authorization_headers))
      end
      
      def set_app_environment(app, environment, rack: nil)
        query = {}
        query[:rack] = rack if rack
        parsed_response!(self.class.post("/apps/#{app}/environment", query: query, body: environment, headers: authorization_headers))
      end
      
      def delete_app_environment_key(app, key, rack: nil)
        query = {}
        query[:rack] = rack if rack
        parsed_response!(self.class.delete("/apps/#{app}/environment/#{key}", query: query, headers: authorization_headers))
      end
      
      def app_formation(app, rack: nil)
        raise 'Not implemented'
      end
      
      def create_app_formation_process(app, process, rack: nil, count: nil, memory: nil)
        raise 'Not implemented'
      end
      
      def app_parameters(app, rack: nil)
        raise 'Not implemented'        
      end
      
      def set_app_parameters(app, parameters, rack: nil)
        raise 'Not implemented'        
      end
      
      def app_processes(app, rack: nil, stats: nil)
        raise 'Not implemented'        
      end
      
      def delete_app_process(app, process, rack: nil)
        raise 'Not implemented'        
      end
      
      def app_process(app, process, rack: nil)
        raise 'Not implemented'        
      end
      
      def run_app_process(app, process, rack: nil, command: nil)
        raise 'Not implemented'        
      end
      
      def app_releases(app, rack: nil)
        query = {}
        query[:rack] = rack if rack
        parsed_response!(self.class.get("/apps/#{app}/releases", query: query, headers: authorization_headers))      
      end
      
      def app_release(app, release, rack: nil)
        query = {}
        query[:rack] = rack if rack
        parsed_response!(self.class.get("/apps/#{app}/releases/#{release}", query: query, headers: authorization_headers))      
      end
      
      def promote_app_release(app, release, rack: nil)
        query = {}
        query[:rack] = rack if rack
        parsed_response!(self.class.get("/apps/#{app}/releases/#{release}/promote", query: query, headers: authorization_headers))      
      end
      
      def app_ssls(app, rack: nil)
        query = {}
        query[:rack] = rack if rack
        parsed_response!(self.class.get("/apps/#{app}/ssl", query: query, headers: authorization_headers))
      end
      
      def set_app_ssl(app, process, port, rack: nil)
        raise 'Not implemented'    
      end
      
      def certificates
        raise 'Not implemented'    
      end
      
      def add_certificate(public, private, chain: nil)
        raise 'Not implemented'    
      end
      
      def generate_certificate(domains: nil)
        raise 'Not implemented'    
      end
      
      def delete_certificate(id: nil)
        raise 'Not implemented'    
      end
      
      def instances
        raise 'Not implemented'    
      end
      
      def instances_keyroll
        raise 'Not implemented'    
      end
      
      def delete_instance(id: nil)
        raise 'Not implemented'    
      end
      
      def delete_registries
        raise 'Not implemented'    
      end
      
      def registries
        raise 'Not implemented'    
      end
      
      def create_registry(server: nil, username: nil, password: nil)
        raise 'Not implemented'    
      end
      
      def services
        raise 'Not implemented'    
      end
      
      def create_service(name, type)
        raise 'Not implemented'    
      end
      
      def delete_service(name)
        raise 'Not implemented'    
      end
      
      def service(name)
        raise 'Not implemented'    
      end
      
      def create_service_link(service, app)
        raise 'Not implemented'    
      end
      
      def delete_service_link(service, app)
        raise 'Not implemented'    
      end
      
      def system(rack: nil)
        raise 'Not implemented'    
      end
      
      def update_system(count: nil, type: nil, version: nil)
        raise 'Not implemented'    
      end
      
      def system_capacity
        raise 'Not implemented'    
      end
      
      private
      def parsed_response!(response)
        raise "Error: #{response.code} #{response.body}" unless response.code == 200
        response.parsed_response        
      end
      
      def authorization_headers
        auth_b64 = Base64.encode64("convox:#{@api_key}")
        {'Authorization' => "Basic #{auth_b64}"}
      end
    end
  end
end