module ActiveRecord  # :nodoc:
  module ConnectionAdapters  # :nodoc:
    module PostGIS  # :nodoc:
      class PostGISDatabaseTasks < ::ActiveRecord::Tasks::PostgreSQLDatabaseTasks  # :nodoc:

        def initialize(config)
          super
          ensure_installation_configs
        end

        def setup_gis
          establish_su_connection
          if extension_names
            setup_gis_from_extension
          end
          establish_connection(configuration)
        end

        # Override to set the database owner and call setup_gis
        def create(master_established = false)
          establish_master_connection unless master_established
          extra_configs = { 'encoding' => encoding }
          extra_configs['owner'] = username if has_su?
          connection.create_database(configuration['database'], configuration.merge(extra_configs))
          setup_gis
        rescue ::ActiveRecord::StatementInvalid => error
          if /database .* already exists/ === error.message
            raise ::ActiveRecord::Tasks::DatabaseAlreadyExists
          else
            raise
          end
        end

        private

        # Override to use su_username and su_password
        def establish_master_connection
          establish_connection(configuration.merge(
            'database'           => 'postgres',
            'password'           => su_password,
            'schema_search_path' => 'public',
            'username'           => su_username,
          ))
        end

        def establish_su_connection
          establish_connection(configuration.merge(
            'password'           => su_password,
            'schema_search_path' => 'public',
            'username'           => su_username,
          ))
        end

        def username
          @username ||= configuration['username']
        end

        def quoted_username
          @quoted_username ||= ::ActiveRecord::Base.connection.quote_column_name(username)
        end

        def password
          @password ||= configuration['password']
        end

        def su_username
          @su_username ||= configuration['su_username'] || username
        end

        def su_password
          @su_password ||= configuration['su_password'] || password
        end

        def has_su?
          @has_su = configuration.include?('su_username') unless defined?(@has_su)
          @has_su
        end

        def search_path
          @search_path ||= configuration['schema_search_path'].to_s.strip.split(',').map(&:strip)
        end

        def extension_names
          @extension_names ||= begin
            extensions = configuration['postgis_extension']
            case extensions
            when ::String
              extensions.split(',')
            when ::Array
              extensions
            else
              ['postgis']
            end
          end
        end

        def ensure_installation_configs
          if configuration['setup'] == 'default' && !configuration['postgis_extension']
            share_dir = `pg_config --sharedir`.strip rescue '/usr/share'
            control_file = ::File.expand_path('extension/postgis.control', share_dir)
            if ::File.readable?(control_file)
              configuration['postgis_extension'] = 'postgis'
            end
          end
        end

        def setup_gis_from_extension
          extension_names.each do |extname|
            if extname == 'postgis_topology'
              raise ::ArgumentError, "'topology' must be in schema_search_path for postgis_topology" unless search_path.include?('topology')
              connection.execute("CREATE EXTENSION IF NOT EXISTS #{extname} SCHEMA topology")
            else
              if (postgis_schema = configuration['postgis_schema'])
                schema_clause = "WITH SCHEMA #{postgis_schema}"
                unless schema_exists?(postgis_schema)
                  connection.execute("CREATE SCHEMA #{postgis_schema}")
                  connection.execute("GRANT ALL ON SCHEMA #{postgis_schema} TO PUBLIC")
                end
              else
                schema_clause = ''
              end

              connection.execute("CREATE EXTENSION IF NOT EXISTS #{extname} #{schema_clause}")
            end
          end
        end

        def schema_exists?(schema_name)
          connection.execute("SELECT schema_name FROM information_schema.schemata WHERE schema_name = '#{schema_name}'").any?
        end
      end

      ::ActiveRecord::Tasks::DatabaseTasks.register_task(/postgis/, PostGISDatabaseTasks)

    end
  end
end