require 'pg'

class DavicalDb
  #
  # DAViCal only supports Postgres, so even if we ever are
  # database-agnostic, this plugin can't be.
  #
  include Plugin

  def initialize()
    cfg = Configuration.new()
    @db_host = cfg.davical_dbhost
    @db_port = cfg.davical_dbport
    @db_opts = cfg.davical_dbopts
    @db_tty  = cfg.davical_dbtty
    @db_name = cfg.davical_dbname
    @db_user = cfg.davical_dbuser
    @db_pass = cfg.davical_dbpass
  end


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


  def describe_account(account)
    principal_id = self.get_principal_id(account)

    if principal_id.nil?
      return 'User not found'
    else
      return "Principal ID: #{principal_id}"
    end
  end


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


  def delete_account(account)
    # Delete the given username. DAViCal uses foreign keys properly
    # and only supports postgres, so we let the ON DELETE CASCADE
    # trigger handle most of the work.
    sql_queries = ['DELETE FROM usr WHERE username = $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 DAViCal.
    davical_accounts = self.get_davical_usernames()
    return davical_accounts - db_accounts
  end


  protected;

  def get_principal_id(account)
    principal_id = nil

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

      sql_query =  "SELECT principal.principal_id "
      sql_query += "FROM (principal INNER JOIN usr "
      sql_query += "      ON principal.user_no = usr.user_no) "
      sql_query += "WHERE usr.username = $1;"

      connection.query(sql_query, [account]) do |result|
        if result.num_tuples > 0
          principal_id = result[0]['principal_id']
        end
      end

      connection.close()

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

    return principal_id
  end


  def get_davical_usernames()
    usernames = []

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

      # User #1 is the super-user, and not tied to an email address.
      sql_query  = 'SELECT username FROM usr WHERE user_no > 1;'

      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