require File.dirname(__FILE__) + '/test_helper'


class TC_NERA_PARAM_LAYER_CONTROLLER < Test::Unit::TestCase

  def setup
    @testdir = 'test_sim_controller'
    FileUtils.mkdir(@testdir)
    FileUtils.chdir(@testdir)
    @db_folder = "nera_db"
    NERA::DbFolders.create_db( @db_folder)
    @dbf = NERA::DbFolders.new( @db_folder)
    @slc = NERA::SimulatorLayerController.new( @db_folder)
    @plc = NERA::ParameterLayerController.new( @db_folder, "Ising")
  end

  def teardown
    FileUtils.chdir('..')
    FileUtils.rm_r(@testdir)
  end

  def test_constructor
    assert_raise( ArgumentError) {
      NERA::ParameterLayerController.new( @dbf,1)
    }
    assert_raise( ArgumentError) {
      NERA::ParameterLayerController.new( Temp,1)
    }
    assert_raise( ArgumentError) {
      x = NERA::ParameterLayerController.new( @dbf, "1")
    }
    assert_raise( RuntimeError) {
      x = NERA::ParameterLayerController.new( @db_folder, "Unknown")
    }
  end

  def test_convert_to_recent_format
    f = @plc.create_a_new_parameter_set( {:L => 96, :K => 0.25, :tmax => 128} )
    io = File.open( File.join( @db_folder, "Tables", "Ising", "parameters.pstore") ,'w')
    d = DateTime.now
    Marshal.dump({ 1 => {:id => 1, :created_at => d, :updated_at => d, :in_trashbox? => :active, :L => 96, :K => 0.25, :tmax => 128 }, :max_id => 1} , io )
    io.flush
    plc = NERA::ParameterLayerController.new( @db_folder, "Ising")
    loaded = YAML.load( File.open( File.join( @db_folder, "Ising", "parameters.yml") ) )
    assert( loaded[0].has_key?( :num_finished_runs) )
    assert( loaded[0].has_key?( :num_all_runs) )
    assert_equal( 0, loaded[0][:num_all_runs])
    assert_equal( 0, loaded[0][:num_finished_runs])

    f = @plc.create_a_new_parameter_set( {:L => 32, :K => 0.25, :tmax => 128} )
    rlc = NERA::RunLayerController.new( @db_folder, "Ising", f)
    assert( rlc.create_jobs(3) )
    io = File.open( File.join( @db_folder, "Tables", "Ising", "parameters.pstore") ,'w')
    Marshal.dump( { 1 => {:id => 1, :created_at => d, :updated_at => d, :in_trashbox? => :active, :L => 96, :K => 0.25, :tmax => 128 },
                    2 => {:id => 2, :created_at => d, :updated_at => d, :in_trashbox? => :active, :L => 32, :K => 0.25, :tmax => 128 },
                    :max_id => 2 } , io )
    io.flush
    
    plc = NERA::ParameterLayerController.new( @db_folder, "Ising")
    loaded = YAML.load( File.open( File.join( @db_folder, "Ising", "parameters.yml") ) )
    assert( loaded[1].has_key?( :num_finished_runs) )
    assert( loaded[1].has_key?( :num_all_runs) )
    assert_equal( 3, loaded[1][:num_all_runs])
    assert_equal( 0, loaded[1][:num_finished_runs])

    assert( @plc.move_a_parameter_set_into_trashbox(1) )
    io = File.open( File.join( @db_folder, "Tables", "Ising", "parameters.pstore") ,'w')
    Marshal.dump( { 1 => {:id => 1, :created_at => d, :updated_at => d, :in_trashbox? => :trashbox, :L => 96, :K => 0.25, :tmax => 128 },
                    2 => {:id => 2, :created_at => d, :updated_at => d, :in_trashbox? => :active, :L => 32, :K => 0.25, :tmax => 128 },
                    :max_id => 2 } , io )
    io.flush
    plc = NERA::ParameterLayerController.new( @db_folder, "Ising")
    loaded = YAML.load( File.open( File.join( @db_folder, "Ising", "parameters.yml") ) )
    assert_equal( false, loaded[0].has_key?( :num_finished_runs) ) # only active records can be updated
    assert_equal( false, loaded[0].has_key?( :num_all_runs) )
    assert( loaded[1].has_key?( :num_finished_runs) ) # only active records can be updated
    assert( loaded[1].has_key?( :num_all_runs) )

    assert( plc.revert_a_parameter_set_in_trashbox(1) )
    loaded = YAML.load( File.open( File.join( @db_folder, "Ising", "parameters.yml") ) )
    assert( loaded[0].has_key?( :num_finished_runs) ) # format is converted when reverted
    assert( loaded[0].has_key?( :num_all_runs) )
  end
  
  def test_parameters_list_in_csv
    header, list = @plc.parameters_list_in_csv
    assert( header.is_a?(String) )
    assert_equal( "id, num_runs, created_at, updated_at, L, K, tmax", header)
    assert( list.is_a?(Array) )
    assert_equal( 0, list.size)

    f = @plc.create_a_new_parameter_set( {:L => 96, :K => 0.25, :tmax => 128} )
    assert_equal( 1, f)
    header, list = @plc.parameters_list_in_csv
    assert( header.is_a?(String) )
    assert_equal( "id, num_runs, created_at, updated_at, L, K, tmax", header)
    assert( list.is_a?(Array) )
    assert_equal( 1, list.size)
    dstr = DateTime.now.to_s.split('T')[0]
    assert_equal( "1, 0/0, #{dstr}, #{dstr}, 96, 0.25, 128", list[0])

    f = @plc.create_a_new_parameter_set( {:L => 32} )
    assert_equal( 2, f)
    header, list = @plc.parameters_list_in_csv
    assert_equal( 2, list.size)
    assert_equal( "1, 0/0, #{dstr}, #{dstr}, 96, 0.25, 128", list[0])
    dstr = DateTime.now.to_s.split('T')[0]
    assert_equal( "2, 0/0, #{dstr}, #{dstr}, 32, 0.223, 512", list[1])

    @plc.move_a_parameter_set_into_trashbox(1)
    header, list = @plc.parameters_list_in_csv
    assert_equal( 1, list.size)
    assert_equal( "2, 0/0, #{dstr}, #{dstr}, 32, 0.223, 512", list[0])

=begin    
    rlc = NERA::RunLayerController.new( @db_folder, "Ising", 2)
    assert( rlc.create_jobs(3), 2 )
    header, list = @plc.parameters_list_in_csv
    assert_equal( "2, 0/6, #{dstr}, #{dstr}, 32, 0.223, 512", list[0])
    assert( rlc.create_jobs(1) )
    assert_equal( "2, 0/4, #{dstr}, #{dstr}, 32, 0.223, 512", list[0])
=end
  end

  def add_three
    f = @plc.create_a_new_parameter_set( {:L => 32, :K => 0.01, :tmax => 1} )
    f = @plc.create_a_new_parameter_set( {:L => 64, :K => 0.02, :tmax => 2} )
    f = @plc.create_a_new_parameter_set( {:L => 96, :K => 0.03, :tmax => 3} )
  end

  def test_get_id_from_csv_string
    add_three
    header, list = @plc.parameters_list_in_csv
    assert_equal( 1, @plc.get_id_from_csv_string( list[0]) )
    assert_equal( 2, @plc.get_id_from_csv_string( list[1]) )
    assert_equal( 3, @plc.get_id_from_csv_string( list[2]) )
  end

  def test_find_ids_by_parameter_hash
    add_three
    h = {:L => 96, :K => 0.03, :tmax => 3}
    assert_equal( [3], @plc.find_ids_by_parameter_hash(h))
    f = @plc.create_a_new_parameter_set( {:L => 96, :K => 0.03, :tmax => 4} )
    assert_equal( [3,4], @plc.find_ids_by_parameter_hash( {:L => 96}))
    assert_nil( @plc.find_ids_by_parameter_hash( {:L => 999}))
  end
  
  def test_list_of_parameters
    p1 = @plc.list_of_parameters
    p2 = [ [:L, Integer, 32],
           [:K, Float, 0.223],
           [:tmax, Integer, 512]
         ]
    assert_equal( p2, p1)

    add_three
    p3 = @plc.list_of_parameters(2)
    p4 = [ [:L, Integer, 64],
           [:K, Float, 0.02],
           [:tmax, Integer, 2]
         ]
    assert_equal( p4, p3)

    p5 = @plc.list_of_parameters(5)
    pp p5
    assert_equal( p2, p5)
  end

  def test_path_to_param_layer
    assert_equal( "nera_db/Ising/", @plc.path_to_param_layer)
  end

  def test_create_a_new_parameter_set
    logp = @db_folder+'/Tables/logfile.txt'
    s1 = File.open(logp,'r').readlines.size
    f = @plc.create_a_new_parameter_set( {:L => 32, :K => 0.01, :tmax => 1} )
    assert_equal( 1, f)
    s2 = File.open(logp,'r').readlines.size
    assert_equal( s1+1, s2)
    f = @plc.create_a_new_parameter_set( {:L => 64, :K => 0.02} )
    assert_equal( 2, f)
    f = @plc.create_a_new_parameter_set( {:L => 96, :tmax => 3} )
    assert_equal( 3, f)
    f = @plc.create_a_new_parameter_set( {:L => 64, :K => 0.02} )
    assert_nil( f)
    assert_raise( ArgumentError) {
      f = @plc.create_a_new_parameter_set( {:L => 64, :unknown => 0.02} )
    }
    assert_raise( ArgumentError) {
      f = @plc.create_a_new_parameter_set( {:L => 64, :K => 2} )
    }
    assert_raise( ArgumentError) {
      f = @plc.create_a_new_parameter_set( [64,0.01,3] )
    }
    header, list = @plc.parameters_list_in_csv
    d = DateTime.now.to_s.split('T')[0]
    l = [ "1, 0/0, #{d}, #{d}, 32, 0.01, 1",
          "2, 0/0, #{d}, #{d}, 64, 0.02, 512",
          "3, 0/0, #{d}, #{d}, 96, 0.223, 3"]
    assert_equal( l, list)
  end

  def test_move_a_parameter_set_into_trashbox
    add_three
    logp = @db_folder+'/Tables/logfile.txt'
    s1 = File.open(logp,'r').readlines.size
    f = @plc.move_a_parameter_set_into_trashbox(2)
    assert_equal( true, f)
    s2 = File.open(logp,'r').readlines.size
    assert_equal( s1+1,s2)
    header, list = @plc.parameters_list_in_csv
    assert_equal( 2, list.size)
    f = @plc.move_a_parameter_set_into_trashbox(2)
    assert_nil( f)
    f = @plc.move_a_parameter_set_into_trashbox(5)
    assert_nil( f)
    assert_raise( ArgumentError) {
      f = @plc.move_a_parameter_set_into_trashbox("1")
    }
  end

  def test_trashbox_parameter_list_in_csv
    add_three
    h, l = @plc.parameters_list_in_csv
    h2, l2 = @plc.trashbox_parameter_list_in_csv
    assert_equal( h, h2)
    assert_equal( [], l2)
    @plc.move_a_parameter_set_into_trashbox(2)
    h2, l2 = @plc.trashbox_parameter_list_in_csv
    assert_equal( l[1], l2[0])
  end
  
  def test_revert_a_parameter_set_in_trashbox
    add_three
    h_org, l_org = @plc.parameters_list_in_csv
    f = @plc.move_a_parameter_set_into_trashbox(2)
    logp = @db_folder+'/Tables/logfile.txt'
    s1 = File.open(logp,'r').readlines.size
    f = @plc.revert_a_parameter_set_in_trashbox(2)
    assert(f)
    s2 = File.open(logp,'r').readlines.size
    assert_equal( s1+1, s2)
    h2, l2 = @plc.parameters_list_in_csv
    assert_equal( l_org, l2)
    h3, l3 = @plc.trashbox_parameter_list_in_csv
    assert_equal( 0, l3.size)

    f = @plc.revert_a_parameter_set_in_trashbox(2)
    assert_nil( f)
    f = @plc.revert_a_parameter_set_in_trashbox(100)
    assert_nil( f)

    assert_raise( ArgumentError) {
      @plc.revert_a_parameter_set_in_trashbox("2")
    }
  end

  def test_delete_a_parameter_set
    add_three
    h_org, l_org = @plc.parameters_list_in_csv
    @plc.move_a_parameter_set_into_trashbox(2)
    logp = @db_folder+'/Tables/logfile.txt'
    s1 = File.open(logp,'r').readlines.size
    s = @plc.delete_a_parameter_set(2)
    assert(s)
    s2 = File.open(logp,'r').readlines.size
    assert_equal( s1+1, s2)
    ht, lt = @plc.trashbox_parameter_list_in_csv
    assert_equal( [], lt)
    
    n = @plc.revert_a_parameter_set_in_trashbox(2)
    assert_nil(n)
    
    n = @plc.revert_a_parameter_set_in_trashbox(100)
    assert_nil(n)

    n = @plc.revert_a_parameter_set_in_trashbox(1)
    assert_nil(n)

    assert_raise( ArgumentError) {
      n = @plc.revert_a_parameter_set_in_trashbox("2")
    }
  end

end