require 'spec_helper'

describe CellSet::CellSet do

  context "attributes" do
    it { should have_accessor(:axes) }

    context "axes" do
      before(:each) do
        @cell_set = Factory.build(:cell_set)
      end

      let(:column_axis) do
        Factory.build(:cell_set_axis, :axis_ordinal => 0)
      end

      let(:row_axis) do
        Factory.build(:cell_set_axis, :axis_ordinal => 1)
      end

      it "should accept an array of CellSetAxis" do
        axes = [column_axis, row_axis]
        lambda{@cell_set.axes = axes}.should_not raise_error
      end

      it "should not accept CellSetAxis or any other object" do
        lambda{@cell_set.axes = column_axis}.should raise_error
      end

      it "should not accept an array with items that are not a CellSetAxis" do
        axes = [column_axis, Object.new]
        lambda{@cell_set.axes = axes}.should raise_error
      end

      it "should accept a Hash as would be assigned by CellSet#from_json" do
        hsh = [
          column_axis.as_json,
          row_axis.as_json
        ]
        lambda{@cell_set.axes = hsh}.should_not raise_error
        @cell_set.axes[0].should == column_axis
        @cell_set.axes[0].should_not == row_axis
        @cell_set.axes[1].should == row_axis
        @cell_set.axes[1].should_not == column_axis
      end

      it "should accept a Hash as would be assigned by CellSet#from_json and assign cell_set" do
        hsh = [
            column_axis.as_json,
            row_axis.as_json
        ]
        lambda{@cell_set.axes = hsh}.should_not raise_error
        @cell_set.axes.each do |axis|
          axis.cell_set.should == @cell_set
        end
      end

      it "should accept an array of CellSetAxis and assign cell_set" do
        axes = [column_axis, row_axis]
        lambda{@cell_set.axes = axes}.should_not raise_error
        @cell_set.axes.each do |axis|
          axis.cell_set.should == @cell_set
        end
      end
    end

    context "initialize" do
      let(:cell_set) do
        Factory.build(:cell_set)
      end

      it "should set axes to an empty array" do
        cell_set.instance_variable_get(:@axes).should == []
      end

      it "should set cellHash to empty hash" do
        cell_set.instance_variable_get(:@cellHash).should == {}
      end
    end
  end

  context "cells" do
    let(:cellHash) do
      {
        "0" => {
          "formatted_value" => "10.0",
          "value" => 10.0
        },
        "4" => {
          "formatted_value" => "11.0",
          "value" => 11.0
        },
        "6" => {
          "formatted_value" => "12.0",
          "value" => 12.0
        }
      }
    end

    let(:cell_set) do
      cell_set = Factory.build(:cell_set)

      cell_set.axes = [0, 1].map do |ordinal|
        axis = Factory.build(:cell_set_axis, :axis_ordinal => ordinal)
        axis.should_receive(:positionCount).at_least(:once).and_return(5)
        axis
      end

      cell_set.instance_variable_set(:@cellHash, cellHash)

      cell_set
    end

    it "should have maxOrdinal" do
      cell_set.maxOrdinal.should == 25
    end

    it "should have cells" do
      cell_set.maxOrdinal.times do |num|
        if cellHash.keys.include?(num.to_s)
          cell_set.cell(num).value.should == cellHash[num.to_s]["value"]
          cell_set.cell(cell_set.ordinalToCoordinates(num)).value == cellHash[num.to_s]["value"]
        else
          cell_set.cell(num).value.should be_nil
          cell_set.cell(cell_set.ordinalToCoordinates(num)).value.should be_nil
        end
      end
    end
  end

  context "Serialization" do
    let(:column_position) do
      Factory.build(:position, :ordinal => 0)
    end

    let(:row_position) do
      Factory.build(:position, :ordinal => 1)
    end

    let(:column_axis) do
      Factory.build(:cell_set_axis, :axis_ordinal => 0, :positions => [column_position])
    end

    let(:row_axis) do
      Factory.build(:cell_set_axis, :axis_ordinal => 1, :positions => [row_position])
    end

    let(:cell_set) do
      Factory.build(:cell_set, :axes => [column_axis, row_axis])
    end

    context "JSON" do
      it "should serialize" do
        cell_set.as_json.should == {
          "axes" => [column_axis, row_axis],
          "cells" => {}
        }
      end

      it "should serialize with root" do
        cell_set.as_json(:root => true).should == {
          "cell_set" => {
            "axes" => [column_axis, row_axis],
            "cells" => {}
          }
        }
      end

      it "should serialize only cells" do
        cell_set.as_json(:only => "cells").should == {
          "cells" => {}
        }
      end

      it "should serialize excluding cells" do
        cell_set.as_json(:except => "cells").should == {
          "axes" => [column_axis, row_axis]
        }
      end

      it "should serialize only axes" do
        cell_set.as_json(:only => "axes").should == {
          "axes" => [column_axis, row_axis]
        }
      end

      it "should de-serialize" do
        json = cell_set.to_json
        ::CellSet::CellSet.new.from_json(json).to_json.should == json
      end

      it "should de-serialize frozen" do
        ::CellSet::CellSet.new.from_json(cell_set.to_json).frozen?.should be_true
      end
    end
  end

  context "to_series_list" do
    let(:column_members) do
      begin
        3.times.map do |i|
          Factory.build(:member, :ordinal => i)
        end
      end
    end

    let(:row_members) do
      begin
        2.times.map do |i|
          Factory.build(:member, :ordinal => i)
        end
      end
    end

    let(:column_positions) do
      5.times.map do |i|
        # Un-memoize to make column_members unique for every position
        __memoized.delete(:column_members)
        Factory.build(:position, :ordinal => i, :members => column_members)
      end
    end

    let(:row_positions) do
      2.times.map do |i|
        # Un-memoize to make row_members unique for every position
        __memoized.delete(:row_members)
        Factory.build(:position, :ordinal => i, :members => row_members)
      end
    end

    let(:column_axis) do
      Factory.build(:cell_set_axis, :axis_ordinal => 0, :positions => column_positions)
    end

    let(:row_axis) do
      Factory.build(:cell_set_axis, :axis_ordinal => 1, :positions => row_positions)
    end

    let(:cells) do
      cellHash = {}
      (column_positions.length * row_positions.length).times do |ordinal|
        value = Random.new.rand(0.0..1000.0).round(2)
        cellHash[ordinal.to_s] = {
          "value" => value,
          "formatted_value" => value.to_s
        }
      end
      cellHash
    end

    let(:cell_set) do
      Factory.build(:cell_set, :axes => [column_axis, row_axis], :cells => cells)
    end

    it "should have the same number of series as row positions" do
      cell_set.to_series_list.length.should == row_positions.length
    end

    it "should have the same number of series as column positions" do
      series_list = cell_set.to_series_list(:labels => {:axis_ordinal => 1}, :data => {:axis_ordinal => 0})
      series_list.length.should == column_positions.length
    end

    params_list = {
      "row" => {:labels => {:axis_ordinal => 0}, :data => {:axis_ordinal => 1}},
      "column" => {:labels => {:axis_ordinal => 1}, :data => {:axis_ordinal => 0}}
    }

    context "series name" do
      params_list.each do |order, params|
        it "should have series name in #{order} series order" do
          series_list = cell_set.to_series_list(params)
          series_list.each_index do |index|
            axis_ordinal = params[:data][:axis_ordinal]
            axis = cell_set.axes[axis_ordinal]
            depth = axis.positions[index].members.length - 1
            series_list[index][:name].should == axis.positions[index].members[depth].name
          end
        end
      end
    end

    context "series labels" do
      params_list.each do |order, params|
        it "should have series labels in #{order} series order" do
          series_list = cell_set.to_series_list(params)
          series_list.each_index do |index|
            axis_ordinal = params[:labels][:axis_ordinal]
            axis = cell_set.axes[axis_ordinal]
            depth = axis.positions.first.members.length - 1
            series_list[index][:labels].should == axis.positions.map{|position| position.members[depth].name}
          end
        end
      end
    end

    context "series values" do
      it "should have series values in row series order" do
        params = params_list["row"]
        series_list = cell_set.to_series_list(params)
        series_list.each_index do |index|
          axis_ordinal = params[:labels][:axis_ordinal]
          axis = cell_set.axes[axis_ordinal]
          values = axis.positionCount.times.map do |i|
            cell_set.cell([i, index]).value
          end
          series_list[index][:values].should == values
        end
      end

      it "should have series values in column series order" do
        params = params_list["column"]
        series_list = cell_set.to_series_list(params)
        series_list.each_index do |index|
          axis_ordinal = params[:labels][:axis_ordinal]
          axis = cell_set.axes[axis_ordinal]
          values = axis.positionCount.times.map do |i|
            cell_set.cell([index, i]).value
          end
          series_list[index][:values].should == values
        end
      end
    end

    context "series formatted values" do
      it "should have series formatted values in row series order" do
        params = params_list["row"]
        series_list = cell_set.to_series_list(params)
        series_list.each_index do |index|
          axis_ordinal = params[:labels][:axis_ordinal]
          axis = cell_set.axes[axis_ordinal]
          values = axis.positionCount.times.map do |i|
            cell_set.cell([i, index]).formatted_value
          end
          series_list[index][:formatted_values].should == values
        end
      end

      it "should have series formatted values in column series order" do
        params = params_list["column"]
        series_list = cell_set.to_series_list(params)
        series_list.each_index do |index|
          axis_ordinal = params[:labels][:axis_ordinal]
          axis = cell_set.axes[axis_ordinal]
          values = axis.positionCount.times.map do |i|
            cell_set.cell([index, i]).formatted_value
          end
          series_list[index][:formatted_values].should == values
        end
      end
    end
  end

  if RUBY_PLATFORM == "java"
    #context "Mondrian::OLAP::Result" do
    #  it "should respond to to_cell_set" do
    #    Mondrian
    #  end
    #end

    context "Java::Mondrian::olap4j::MondrianOlap4jCellSet" do

    end
  end

end