require 'pg'

require 'common/plugin'
require 'rm/rm_plugin'

class AgendavDb

  include Plugin
  include RmPlugin

  def initialize()
    cfg = Configuration.new()
    @db_host = cfg.agendav_dbhost
    @db_port = cfg.agendav_dbport
    @db_opts = cfg.agendav_dbopts
    @db_tty  = cfg.agendav_dbtty
    @db_name = cfg.agendav_dbname
    @db_user = cfg.agendav_dbuser
    @db_pass = cfg.agendav_dbpass
  end


  def describe_domain(domain)
    # AgenDAV doesn't have a concept of domains.
    return 'N/A'
  end

  def describe_account(account)
    if self.user_exists(account)
      return "Username: #{account}"
    else
      return 'User not found'
    end
  end

  def delete_domain(domain)
    # AgenDAV doesn't have a concept of domains.
  end

  def delete_account(account)
    # Delete the given username and any records in other tables
    # belonging to it.

    sql_queries = ['DELETE FROM prefs WHERE username = $1;']
    sql_queries << 'DELETE FROM shared WHERE user_from = $1;'

    begin
      connection = PGconn.connect(@db_host,
                                  @db_port,
                                  @db_opts,
                                  @db_tty,
                                  @db_name,
                                  @db_user,
                                  @db_pass)

      sql_queries.each do |sql_query|
        connection.query(sql_query, [account])
      end

      connection.close()

    rescue PGError => e
      # Pretend like we're database-agnostic in case we ever are.
      raise DatabaseError.new(e)
    end

  end


  def get_leftover_domains(db_domains)
    # AgenDAV doesn't have a concept of domains.
    return []
  end


  def get_leftover_accounts(db_accounts)
    # Get a list of all users who have logged in to AgenDAV.
    ad_accounts = self.get_agendav_usernames()
    return ad_accounts - db_accounts
  end


  protected;

  def user_exists(account)
    ad_users = get_agendav_usernames()
    return ad_users.include?(account)
  end

  def get_agendav_usernames()
    usernames = []

    # Just assume PostgreSQL for now.
    begin
      connection = PGconn.connect(@db_host,
                                  @db_port,
                                  @db_opts,
                                  @db_tty,
                                  @db_name,
                                  @db_user,
                                  @db_pass)

      sql_query  = '(SELECT username FROM prefs)'
      sql_query += 'UNION'
      sql_query += '(SELECT user_from FROM shared);'

      connection.query(sql_query) do |result|
        usernames = result.field_values('username')
      end

      connection.close()
    rescue PGError => e
      # Pretend like we're database-agnostic in case we ever are.
      raise DatabaseError.new(e)
    end

    return usernames
  end

end