require 'pg'

class RoundcubeDb

  include Plugin

  def initialize()
    @db_host = Configuration::ROUNDCUBE_DBHOST
    @db_port = Configuration::ROUNDCUBE_DBPORT
    @db_opts = Configuration::ROUNDCUBE_DBOPTS
    @db_tty  = Configuration::ROUNDCUBE_DBTTY
    @db_name = Configuration::ROUNDCUBE_DBNAME
    @db_user = Configuration::ROUNDCUBE_DBUSER
    @db_pass = Configuration::ROUNDCUBE_DBPASS
  end


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

  def describe_account(account)
    user_id = self.get_user_id(account)

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

  def delete_domain(domain)
    # Roundcube 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.
    user_id = self.get_user_id(account)

    # This is mostly unnecessary when using Postgres. The Roundcube
    # developers were nice enough to include DBMS-specific install and
    # upgrade scripts, so Postgres can take advantage of ON DELETE
    # triggers. Here's an example:
    #
    #  ...
    #  user_id integer NOT NULL
    #    REFERENCES users (user_id) ON DELETE CASCADE ON UPDATE CASCADE
    #
    sql_queries = ['DELETE FROM cache WHERE user_id = $1::int;']
    sql_queries << 'DELETE FROM cache_index WHERE user_id = $1::int;'
    sql_queries << 'DELETE FROM cache_messages WHERE user_id = $1::int;'
    sql_queries << 'DELETE FROM cache_thread WHERE user_id = $1::int;'
    sql_queries << 'DELETE FROM contactgroupmembers WHERE contactgroup_id IN (SELECT contactgroup_id FROM contactgroups WHERE user_id = $1::int);'
    sql_queries << 'DELETE FROM contactgroups WHERE user_id = $1::int;'
    sql_queries << 'DELETE FROM contacts WHERE user_id = $1::int;'
    sql_queries << 'DELETE FROM identities WHERE user_id = $1::int;'
    sql_queries << 'DELETE FROM dictionary WHERE user_id = $1::int;'
    sql_queries << 'DELETE FROM searches WHERE user_id = $1::int;'

    # This one is of course necessary with any DBMS.
    sql_queries << 'DELETE FROM users WHERE user_id = $1::int;'

    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, [user_id])
      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)
    # Roundcube doesn't have a concept of domains.
    return []
  end


  def get_leftover_accounts(db_accounts)
    # Given a list of all users who have logged in to Roundcube.
    rc_accounts = self.get_roundcube_usernames()
    return rc_accounts - db_accounts
  end


  protected;

  def get_user_id(account)
    user_id = nil

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

      sql_query = "SELECT user_id FROM users WHERE username = $1;"

      connection.query(sql_query, [account]) do |result|
        if result.num_tuples > 0
          user_id = result[0]['user_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 user_id
  end



  def get_roundcube_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 users;"
      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