require 'flydata/source/generate_source_dump'
require 'flydata/preference/data_entry_preference'
require 'flydata/source_oracle/oracle_component'
require 'flydata/source_oracle/query_based_sync/diff_query_generator'
require 'flydata/source_oracle/table_meta'
require 'flydata-core/oracle/source_pos'
require 'flydata-core/oracle/oracle_client'
require 'flydata-core/oracle/query_helper'
require 'msgpack'

module Flydata
module SourceOracle

class GenerateSourceDump < Source::GenerateSourceDump
  include OracleComponent

  def run_compatibility_check(dump_dir, backup_dir)
    %w(host username database).each do |k|
      if de_prefs[k].to_s.empty?
        raise "'#{k}' is required. Set the value in the conf file " +
              "-> #{Flydata::Preference::DataEntryPreference.conf_path(de)}"
      end
    end
  end

  def confirmation_items
    items = {
      "host"     => de_prefs['host'],
      "port"     => de_prefs['port'],
      "username" => de_prefs['username'],
      "database" => de_prefs['database'],
      "schema"   => de_prefs['schema'],
    }

    items
  end

  DUMP_SIZE_QUERY = <<EOS
SELECT
  sum(bytes) as total_size
FROM
(SELECT segment_name table_name, owner, bytes
FROM dba_segments
WHERE segment_type IN ('TABLE','TABLE PARTITION','TABLE SUBPARTITION')
UNION ALL
SELECT i.table_name, i.owner, s.bytes
FROM dba_indexes i, dba_segments s
WHERE s.segment_name = i.index_name
AND s.owner = i.owner
AND s.segment_type IN ('INDEX','INDEX PARTITION','INDEX SUBPARTITION')
UNION ALL
SELECT l.table_name, l.owner, s.bytes
FROM dba_lobs l, dba_segments s
WHERE s.segment_name = l.segment_name
AND s.owner = l.owner
AND s.segment_type IN ('LOBSEGMENT','LOB PARTITION')
UNION ALL
SELECT l.table_name, l.owner, s.bytes
FROM dba_lobs l, dba_segments s
WHERE s.segment_name = l.index_name
AND s.owner = l.owner
AND s.segment_type = 'LOBINDEX')
WHERE owner = %{schema} and table_name in (%{tables})
EOS

  def dump_size(tables)
    cli = FlydataCore::Oracle::OracleClient.new(de_prefs)

    query = DUMP_SIZE_QUERY % {
      schema: FlydataCore::Oracle::QueryHelper.schema_as_value(de_prefs['schema'],
                                                               de_prefs['username']),
      tables: FlydataCore::Oracle::QueryHelper.tables_as_value(tables)
    }

    cursor = cli.query(query)
    cursor.fetch_hash['TOTAL_SIZE'].to_i
  ensure
    cursor.close rescue nil if cursor
    cli.close if cli
  end

  def dump(tables, file_path = nil, &src_pos_callback)
    io = nil
    if file_path
      io = File.open(file_path, "w")
    else
      raise "dump via pipe has not been implemented yet"
    end

    table_meta = Flydata::SourceOracle::TableMeta.new(de_prefs, tables)
    cli = FlydataCore::Oracle::OracleClient.new(de_prefs)
    table_meta.reload(cli)

    tables_missing_meta = tables.select{|t| tm = table_meta[t]; tm.nil? || tm.empty?}
    unless tables_missing_meta.empty?
      raise "Tables are not available.  Check if the following table(s) exist and are visible: #{tables_missing_meta.join(",")}"
    end

    context = source.sync_generate_table_ddl(dp, nil)
    source_pos = get_source_pos(table_meta.current_scn, &src_pos_callback)

    options = de_prefs.merge(table_meta: table_meta)
    missing_tables = context.each_source_tabledef(tables, options) do |tabledef, error|
      dump_table(tabledef, source_pos, io, cli) if tabledef
    end

    nil
  ensure
    cli.close if cli
    io.close if io
  end

  private

  def get_source_pos(snapshot, &src_pos_callback)
    src_pos = FlydataCore::Oracle::SourcePos.new(snapshot)
    src_pos_callback.call(nil, src_pos)

    src_pos
  end

  NUM_ROWS = 50000

  def dump_table(tabledef, source_pos, io, cli)
    dump_source_table(tabledef, io)

    last_pks = nil
    loop do
      num_rows, last_pks =
        dump_table_chunk(tabledef.table_name, de_prefs['schema'], source_pos, NUM_ROWS,
                         tabledef, tabledef.pk_columns, last_pks, io, cli)
      break if num_rows < NUM_ROWS
    end
  end

  def dump_source_table(tabledef, io)
    columns = {}
    tabledef.column_def.each do |column_name, columndef_str|
      columndef_hash = eval columndef_str
      columns[column_name] = {"column_name" => column_name,
                              "format_type" => columndef_hash["data_type"]}
    end
    source_table_hash = { "table_name" => tabledef.table_name,
                          "columns" => columns }

    io.write(source_table_hash.to_msgpack)
  end

  def dump_table_chunk(table, schema, source_pos, num_rows,
                       tabledef, pk_columns, last_pks, io, cli)
    query = Flydata::SourceOracle::QueryBasedSync::DiffQueryGenerator.new(
              table, schema,
              columns: tabledef.columns,
              to_scn: source_pos.scn,
              pk_columns: pk_columns,
              last_pks: last_pks,
              limit: num_rows).build_query

    column_names = tabledef.columns.inject([]) do |ary, h|
       ary << h[:column]
    end

    res = cli.query(query)
    count = 0
    last_row = nil
    while (row = res.fetch_hash)
      count += 1
      last_row = row
      dump_row(row, column_names, io)
    end

    last_pks = last_row ? pk_columns.collect{|col| last_row[col]} : nil

    [count, last_pks]
  end

  def dump_row(row, columns, io)
    data = columns.collect{|col| row[col] }.to_msgpack
    io.write(data)
  end
end

end
end