module MxHero::API

  class Directory 
    attr_accessor :domain, :type, :address, :port, :ssl, 
      :user, :password, :filter, :base, :next_update, 
      :last_update, :error, :override, :dn_authenticate, 
      :properties

    def initialize(data = {})
      return if data.empty?
      [
        :domain, [:type, :directoryType], [:address, :addres], :port, 
        [:ssl, :sslFlag], :user, :password, :filter, :base, 
        [:next_update, :nextUpdate],
        [:last_update, :lastUpdate],
        :error, [:override, :overrideFlag], 
        [:dn_authenticate, :dnAuthenticate]
      ].each do |property|
        case property
        when Symbol
          send "#{property}=", data[property]
        when Array
          send "#{property.first}=", data[property.first] || data[property.last]
        end
      end
      load_properties(data)
    end

    
    def last_update=(date)
      parse_update_dates(:last_update, date) 
    end

    def next_update=(date)
      parse_update_dates(:next_update, date)
    end

    def update_properties(properties)
      properties.each { |prop, value| send("#{prop}=", value) if respond_to?("#{prop}=") }
    end

    def to_hash
      {
        domain: domain,
        directoryType: type,
        addres: address,
        port: port, 
        sslFlag: ssl, # || false,
        user: user, password: password, 
        filter: filter, base: base,
        nextUpdate: next_update, # || DateTime.now.strftime('%Q'),
        lastUpdate: last_update, # || DateTime.now.strftime('%Q'),
        error: error,
        overrideFlag: override,  #override.nil? ? true : override,
        dnAuthenticate: dn_authenticate,
        properties: properties_field_to_hash
      }
    end

    def to_json
      to_hash.to_json
    end
    
    private
    
    def load_properties(data)
      @properties ||= {}
      props = data[:properties]
      case props
      when Array then (props || []).each { |property| @properties[property[:name].to_sym] = property[:key] }
      when Hash  then @properties = props
      end
    end

    def properties_field_to_hash
      values = []
      (properties || []).each do |name, value|
        values << { name: name, key: value } 
      end
      values
    end
    
    def parse_update_dates(property, date)
      if date.is_a? Integer or date.is_a? String
        instance_variable_set "@#{property}", DateTime.strptime(date.to_s, '%Q')
      else
        instance_variable_set "@#{property}", date
      end
    end

  end
  
  class Directories
    include Communication
    include Urls

    attr_reader :domain

    def initialize(domain, config = {})
      @domain       = domain
      @service_url  = config[:api_url]
      @username     = config[:username]
      @password     = config[:password]
      @verbose      = config[:verbose] || false
    end


    # Fetch the directory information
    #
    # @return [MxHero::API::Directory | nil] the directory or nil when not exist.
    def fetch
      response = call(:get, directories_url)
      if (200..299).include? response.code
        hash = json_parse response.content
        return Directory.new hash
      end
      nil
    end
    
    # Create a directory configuration
    #
    # @return [MxHero::API::Response] that Directory created
    #   In case on error, may be one of the following: 
    #     + domain.ldap.alredy.exists
    #
    def create(directory)
      directory.domain = domain
      response = call(:post, directories_url, directory.to_json, throw_exception: false)
      wrap_response_from response
    end

    # Update the directory configuration
    #
    # @return [MxHero::API::Response] that Directory updated
    #   In case on error, may be one of the following: 
    #     + domain.ldap.not.found
    #
    def update(directory)
      directory.domain = domain
      response = call(:put, directories_url, directory.to_json, throw_exception: false)
      wrap_response_from response
    end

    # Delete the directory configuration
    #
    # @return [MxHero::API::Response] with content empty. 
    #   In case on error, may be one of the following: 
    #     + domain.ldap.not.found : Inexistent group
    def delete
      response = call(:delete, directories_url, throw_exception: false)
      wrap_response_from response
    end


    # -------------------------------------------------------------------------
    private
    
    def wrap_response_from(response)
      content = (200..299).include?(response.code) ? directory_from(response) : json_parse(response.content)
      Response.new(response.status, content) 
    end

    def directory_from(response)
      return nil if response.content.nil? || response.content.empty?
      hash = json_parse response.content
      Directory.new hash
    end

    def directories_url
      domain_by_id_url(domain) + 'adldap' 
    end
  end

end