# -*- coding: utf-8 -*-
require File.join(File.dirname(__FILE__), 'spec_helper')

describe SelectableAttr do
  
  def assert_enum_class_methods(klass, attr = :enum1)
    klass.send("#{attr}_enum").length.should == 3
    expected_hash_array = [
        {:id => 1, :key => :entry1, :name => "エントリ1"},
        {:id => 2, :key => :entry2, :name => "エントリ2"},
        {:id => 3, :key => :entry3, :name => "エントリ3"}
      ]
    klass.send("#{attr}_hash_array").should == expected_hash_array
    klass.send("#{attr}_enum").to_hash_array.should == expected_hash_array
    klass.send("#{attr}_entries").
      map{|entry| {:id => entry.id, :key => entry.key, :name => entry.name} }.
      should == expected_hash_array

    klass.send("#{attr}_ids").should == [1,2,3]
    klass.send("#{attr}_ids", :entry2, :entry3).should == [2,3]
    klass.send("#{attr}_keys").should == [:entry1, :entry2, :entry3]
    klass.send("#{attr}_keys", 1,3).should == [:entry1, :entry3]
    klass.send("#{attr}_names").should == ["エントリ1", "エントリ2", "エントリ3"]
    klass.send("#{attr}_names", 1,2).should == ["エントリ1", "エントリ2"]
    klass.send("#{attr}_names", :entry1, :entry2).should == ["エントリ1", "エントリ2"]
    klass.send("#{attr}_options").should == [['エントリ1', 1], ['エントリ2', 2], ['エントリ3', 3]]
    klass.send("#{attr}_options", :entry2, :entry3).should == [['エントリ2', 2], ['エントリ3', 3]]
    klass.send("#{attr}_options", 1,2).should == [['エントリ1', 1], ['エントリ2', 2]]

    klass.send("#{attr}_id_by_key", nil).should be_nil
    klass.send("#{attr}_id_by_key", :entry1).should == 1
    klass.send("#{attr}_id_by_key", :entry2).should == 2
    klass.send("#{attr}_id_by_key", :entry3).should == 3
    klass.send("#{attr}_name_by_key", nil).should be_nil
    klass.send("#{attr}_name_by_key", :entry1).should == "エントリ1"
    klass.send("#{attr}_name_by_key", :entry2).should == "エントリ2"
    klass.send("#{attr}_name_by_key", :entry3).should == "エントリ3"

    klass.send("#{attr}_key_by_id", nil).should be_nil
    klass.send("#{attr}_key_by_id", 1).should == :entry1
    klass.send("#{attr}_key_by_id", 2).should == :entry2
    klass.send("#{attr}_key_by_id", 3).should == :entry3
    klass.send("#{attr}_name_by_id", nil).should be_nil
    klass.send("#{attr}_name_by_id", 1).should == "エントリ1"
    klass.send("#{attr}_name_by_id", 2).should == "エントリ2"
    klass.send("#{attr}_name_by_id", 3).should == "エントリ3"
  end
  
  def assert_single_enum_instance_methods(obj, attr = :enum1)
    obj.send("#{attr}=", 1)
    obj.send(attr).should == 1
    obj.enum1_key.should == :entry1 
    obj.enum1_name.should == "エントリ1"
    obj.enum1_entry.to_hash.should == {:id => 1, :key => :entry1, :name => "エントリ1"}
    
    obj.enum1_key = :entry2
    obj.send(attr).should == 2
    obj.enum1_key.should == :entry2
    obj.enum1_name.should == "エントリ2"
    obj.enum1_entry.to_hash.should == {:id => 2, :key => :entry2, :name => "エントリ2"}
    
    obj.send("#{attr}=", 3)
    obj.send(attr).should == 3
    obj.enum1_key.should == :entry3
    obj.enum1_name.should == "エントリ3"
    obj.enum1_entry.to_hash.should == {:id => 3, :key => :entry3, :name => "エントリ3"}
  end
  
  class EnumBase
    include ::SelectableAttr::Base
  end

  class EnumMock1 < EnumBase
    selectable_attr :enum1, :default => 2 do
      entry 1, :entry1, "エントリ1"
      entry 2, :entry2, "エントリ2"
      entry 3, :entry3, "エントリ3"
    end
  end
  
  class EnumMock1WithEnum < EnumBase
    selectable_attr :enum1, :default => 2 do
      entry 1, :entry1, "エントリ1"
      entry 2, :entry2, "エントリ2"
      entry 3, :entry3, "エントリ3"
    end
  end
  
  it "test_selectable_attr1" do
    assert_enum_class_methods(EnumMock1)
    mock1 = EnumMock1.new
    mock1.enum1.should == 2
    assert_single_enum_instance_methods(mock1)
    
    assert_enum_class_methods(EnumMock1WithEnum)
    mock1 = EnumMock1WithEnum.new
    mock1.enum1.should == 2
    assert_single_enum_instance_methods(mock1)
  end
  

  class EnumMock2 < EnumBase
    attr_enumeable_base do |attr|
      attr.to_s.gsub(/(.*)_code(.*)$/){"#{$1}#{$2}"}
    end

    selectable_attr :enum_code1 do
      entry 1, :entry1, "エントリ1"
      entry 2, :entry2, "エントリ2"
      entry 3, :entry3, "エントリ3"
    end
  end

  class EnumMock2WithEnum < EnumBase
    attr_enumeable_base do |attr|
      attr.to_s.gsub(/(.*)_code(.*)$/){"#{$1}#{$2}"}
    end

    enum :enum_code1 do
      entry 1, :entry1, "エントリ1"
      entry 2, :entry2, "エントリ2"
      entry 3, :entry3, "エントリ3"
    end
  end

  it "test_selectable_attr2" do
    assert_enum_class_methods(EnumMock2)
    assert_single_enum_instance_methods(EnumMock2.new, :enum_code1)
    assert_enum_class_methods(EnumMock2WithEnum)
    assert_single_enum_instance_methods(EnumMock2WithEnum.new, :enum_code1)
  end
  

  
  def assert_multi_enum_instance_methods(obj, patterns)
    obj.enum_array1_hash_array.should == [
        {:id => 1, :key => :entry1, :name => "エントリ1", :select => false},
        {:id => 2, :key => :entry2, :name => "エントリ2", :select => false},
        {:id => 3, :key => :entry3, :name => "エントリ3", :select => false}
      ]
    obj.enum_array1_selection.should == [false, false, false]
    obj.enum_array1.should be_nil
    obj.enum_array1_entries.should == []
    obj.enum_array1_keys.should == []
    obj.enum_array1_names.should == []
    
    obj.enum_array1 = patterns[0]
    obj.enum_array1.should == patterns[0]
    obj.enum_array1_hash_array.should == [
        {:id => 1, :key => :entry1, :name => "エントリ1", :select => false},
        {:id => 2, :key => :entry2, :name => "エントリ2", :select => false},
        {:id => 3, :key => :entry3, :name => "エントリ3", :select => false}
      ]
    obj.enum_array1_selection.should == [false, false, false]
    obj.enum_array1_entries.should == []
    obj.enum_array1_keys.should == []
    obj.enum_array1_names.should == []

    obj.enum_array1 = patterns[1]
    obj.enum_array1.should == patterns[1]
    obj.enum_array1_hash_array.should == [
        {:id => 1, :key => :entry1, :name => "エントリ1", :select => false},
        {:id => 2, :key => :entry2, :name => "エントリ2", :select => false},
        {:id => 3, :key => :entry3, :name => "エントリ3", :select => true}
      ]
    obj.enum_array1_selection.should == [false, false, true]
    obj.enum_array1_entries.map(&:id).should == [3]
    obj.enum_array1_keys.should == [:entry3]
    obj.enum_array1_names.should == ['エントリ3']
    
    obj.enum_array1 = patterns[3]
    obj.enum_array1.should == patterns[3]
    obj.enum_array1_hash_array.should == [
        {:id => 1, :key => :entry1, :name => "エントリ1", :select => false},
        {:id => 2, :key => :entry2, :name => "エントリ2", :select => true},
        {:id => 3, :key => :entry3, :name => "エントリ3", :select => true}
      ]
    obj.enum_array1_selection.should == [false, true, true]
    obj.enum_array1_entries.map(&:id).should == [2, 3]
    obj.enum_array1_keys.should == [:entry2, :entry3]
    obj.enum_array1_names.should == ['エントリ2', 'エントリ3']

    obj.enum_array1 = patterns[7]
    obj.enum_array1.should == patterns[7]
    obj.enum_array1_hash_array.should == [
        {:id => 1, :key => :entry1, :name => "エントリ1", :select => true},
        {:id => 2, :key => :entry2, :name => "エントリ2", :select => true},
        {:id => 3, :key => :entry3, :name => "エントリ3", :select => true}
      ]
    obj.enum_array1_selection.should == [true, true, true]
    obj.enum_array1_ids.should == [1, 2, 3]
    obj.enum_array1_entries.map(&:id).should == [1, 2, 3]
    obj.enum_array1_keys.should == [:entry1, :entry2, :entry3]
    obj.enum_array1_names.should == ['エントリ1', 'エントリ2', 'エントリ3']
    
    obj.enum_array1_ids = [1,3]; obj.enum_array1.should == patterns[5]
    obj.enum_array1_ids = [1,2]; obj.enum_array1.should == patterns[6]
    obj.enum_array1_ids = [2]; obj.enum_array1.should == patterns[2]

    obj.enum_array1_keys = [:entry1,:entry3]; obj.enum_array1.should == patterns[5]
    obj.enum_array1_keys = [:entry1,:entry2]; obj.enum_array1.should == patterns[6]
    obj.enum_array1_keys = [:entry2]; obj.enum_array1.should == patterns[2]

    obj.enum_array1_selection = [true, false, true]; obj.enum_array1.should == patterns[5]
    obj.enum_array1_selection = [true, true, false]; obj.enum_array1.should == patterns[6]
    obj.enum_array1_selection = [false, true, false]; obj.enum_array1.should == patterns[2]

    obj.enum_array1_ids = "1,3"; obj.enum_array1.should == patterns[5]
    obj.enum_array1_ids = "1,2"; obj.enum_array1.should == patterns[6]
    obj.enum_array1_ids = "2"; obj.enum_array1.should == patterns[2]
  end
  
  class EnumMock3 < EnumBase
    multi_selectable_attr :enum_array1, :convert_with => :binary_string do
      entry 1, :entry1, "エントリ1"
      entry 2, :entry2, "エントリ2"
      entry 3, :entry3, "エントリ3"
    end
  end
  
  class EnumMock3WithEnumArray < EnumBase
    enum_array :enum_array1, :convert_with => :binary_string do
      entry 1, :entry1, "エントリ1"
      entry 2, :entry2, "エントリ2"
      entry 3, :entry3, "エントリ3"
    end
  end
  
  it "test_multi_selectable_attr_with_binary_string" do
    expected = (0..7).map{|i| '%-03b' % i} # ["000", "001", "010", "011", "100", "101", "110", "111"]
    assert_enum_class_methods(EnumMock3, :enum_array1)
    assert_multi_enum_instance_methods(EnumMock3.new, expected)
    assert_enum_class_methods(EnumMock3WithEnumArray, :enum_array1)
    assert_multi_enum_instance_methods(EnumMock3WithEnumArray.new, expected)
  end

  class EnumMock4 < EnumBase
    multi_selectable_attr :enum_array1 do
      entry 1, :entry1, "エントリ1"
      entry 2, :entry2, "エントリ2"
      entry 3, :entry3, "エントリ3"
    end
  end
  
  class EnumMock4WithEnumArray < EnumBase
    enum_array :enum_array1 do
      entry 1, :entry1, "エントリ1"
      entry 2, :entry2, "エントリ2"
      entry 3, :entry3, "エントリ3"
    end
  end
  
  it "test_multi_selectable_attr2" do
    # [[], [3], [2], [2, 3], [1], [1, 3], [1, 2], [1, 2, 3]]
    expected = 
      (0..7).map do |i|
        s = '%03b' % i
        a = s.split('').map{|v| v.to_i}
        ret = []
        a.each_with_index{|val, pos| ret << pos + 1 if val == 1}
        ret
      end
    assert_enum_class_methods(EnumMock4, :enum_array1)
    assert_multi_enum_instance_methods(EnumMock4.new, expected)
    assert_enum_class_methods(EnumMock4WithEnumArray, :enum_array1)
    assert_multi_enum_instance_methods(EnumMock4WithEnumArray.new, expected)
  end

  class EnumMock5 < EnumBase
    multi_selectable_attr :enum_array1, :convert_with => :comma_string do
      entry 1, :entry1, "エントリ1"
      entry 2, :entry2, "エントリ2"
      entry 3, :entry3, "エントリ3"
    end
  end
  
  class EnumMock5WithEnumArray < EnumBase
    enum_array :enum_array1, :convert_with => :comma_string do
      entry 1, :entry1, "エントリ1"
      entry 2, :entry2, "エントリ2"
      entry 3, :entry3, "エントリ3"
    end
  end
  
  it "test_multi_selectable_attr_with_comma_string" do
    # ["", "3", "2", "2,3", "1", "1,3", "1,2", "1,2,3"]
    expected = 
      (0..7).map do |i|
        s = '%03b' % i
        a = s.split('').map{|v| v.to_i}
        ret = []
        a.each_with_index{|val, pos| ret << pos + 1 if val == 1}
        ret.join(',')
      end
    assert_enum_class_methods(EnumMock5, :enum_array1)
    assert_multi_enum_instance_methods(EnumMock5.new, expected)
    assert_enum_class_methods(EnumMock5WithEnumArray, :enum_array1)
    assert_multi_enum_instance_methods(EnumMock5WithEnumArray.new, expected)
  end
    
  class EnumMock6 < EnumBase
    # self.selectable_attr_name_pattern = /(_cd$|_code$|_cds$|_codes$)/
    selectable_attr :category_id do 
      entry "01", :category1, "カテゴリ1"
      entry "02", :category2, "カテゴリ2"
    end
  end
  
  class EnumMock7 < EnumBase
    self.selectable_attr_name_pattern = /(_cd$|_id$|_cds$|_ids$)/
    selectable_attr :category_id do 
      entry "01", :category1, "カテゴリ1"
      entry "02", :category2, "カテゴリ2"
    end
  end
  
  it "test_selectable_attr_name_pattern" do
    EnumMock6.selectable_attr_name_pattern.should == /(_cd$|_code$|_cds$|_codes$)/
    EnumMock6.respond_to?(:category_enum).should == false
    EnumMock6.respond_to?(:category_id_enum).should == true
    EnumMock6.new.respond_to?(:category_key).should == false
    EnumMock6.new.respond_to?(:category_id_key).should == true
    
    EnumMock7.selectable_attr_name_pattern.should == /(_cd$|_id$|_cds$|_ids$)/
    EnumMock7.respond_to?(:category_enum).should == true
    EnumMock7.respond_to?(:category_id_enum).should == false
    EnumMock7.new.respond_to?(:category_key).should == true
    EnumMock7.new.respond_to?(:category_id_key).should == false
  end

end