# frozen_string_literal: true

params = {

  id: :my_table, left: 0, top: 0, width: 500, height: 399, smooth: 8, color: :yellowgreen,
  columns: { count: 8,
             titles: { 1 => :col1, 3 => :mycol },
             data: { 3 => :col_content },
             actions: { 2 => { touch: :the_action } },
             particles: { color: :blue }
  },
  rows: { count: 6,
          titles: { 1 => :my_first_row, 5 => :other_row },
          data: { 0 => :col_content },
          actions: {},
          particles: { shadows: :black }
  },
  cells: {
    # data: { 0 => :here, 2 => "hello", 4 => :hi, 5 => :good, 7 => :super },
    # actions: { 2 => { touch: :my_lambda } },
    particles: { margin: 9, color: :blue, smooth: 9, shadow: { blur: 9, left: 3, top: 3 } }
  },
  exceptions: {
    columns: {
      # divided: { 2 => 3 },
      fusion: { 1 => [3, 5], 7 => [2, 5] }
    },
    rows: {
      divided: { 1 => 3 },
      fusion: { 2 => [0, 3], 5 => [2, 5] }
    }
  }
}
m = matrix(params)

found = m.columns(5) do |el|
  el.color(:yellow)
end

m.rows(3) do |el|
  el.color(:orange)
end

m.rows(1) do |el|
  el.color(:lightgray)
end

found.data.each do |el|
  el.color(:red)
end

# found.data[0..2].each do |el|
#   el.color(:cyan)
# end
#
grab(:my_table_21).color(:pink)
grab(:my_table_26).color(:purple)
# m.cells([20, 5]).rotate(15)
# m.cell(9).color(:black)
# test = m.cells([23, 26])
# test.color(:blue)
# m.columns(6).data[0..3].color(:white)

grab(m.id).drag({ move: true }) do |e|
  puts e
end
wait 1 do
  m.add_columns(3)
  m.rows(3) do |el|
    el.color(:orange)
  end
    wait 1 do
      m.add_rows(4)
      m.rows(1) do |el|
        el.color(:lightgray)
      end
      wait 1 do
        found.data.each do |el|
          el.color(:red)
        end
        m.resize(330, 300)

        m.fusion(rows: { 2 => [0, 3], 3 => [2, 5] })
      end
    end
end

#
m.fusion(columns: { 3=>  [3, 5], 4 => [2, 5] })
m.fusion(rows: { 0 => [0, 3], 3 => [5, 9] })
# m.override( {
#              columns: { number: [ 0, 3 ] ,width: 200},
#              rows: { number: [ 1, 4 ] ,height: 200},
#            })
m.last(:rows) do |el|
  el.color(:violet)
end
m.divide( rows: {1 => 3})
m.cell(9).box({left: 0, top: 0, id: :the_big_one, width: 66, height: 66, color: :black})
# m.cell(9).content([box({ left: 0, top: 0, id: :another_one, width: 66, height: 66, color: :black })])




# # puts  m.cell(9).content
# m.relations({ relation_1: {
#   # start: {cell_id => out_nb},
#   # end: {cell_id => in_nb},
#   start: { 9 => 2 },
#   end: { 2 => 3 }
# } })
# m.add({ relations: {
#   # start: {cell_id => out_nb},
#   # end: {cell_id => in_nb},
#   rel_2: { start: { 7 => 3 },
#     end: { 1 => 4 } }
# }
#              })
# m.delete({ relations: :rel_2 })
# # alert m.relations
# # "sourceComponent": 0,
# #   "sourceOutputSlot": 1,
# #   "targetComponent": 1,
# #   "targetInputSlot": 1
# # puts m.cell(9)
# # m.children.each do |child|
# #   puts "#{grab(child).id} : #{grab(child).width}"
# # end
#
# # alert(grab("my_table_9"))
# # grab("my_table_9").children .each do |child|
# #   grab(child).color(:white)
# # end
# matrix_ratio=m.height/m.width
# # alert prev_size
# $window.on :resize do |e|
#   # m.top(0)
#   # m.left(0)
#   # ratio_w=m.width.value/$window.view.width
#   # ratio_h=m.height.value/$window.view.height
#   # puts "=====> :#{ratio_w}"
#   # m.resize(ratio_w*$window.view.width,ratio_h*$window.view.height)
#   m.resize($window.view.width, $window.view.width*matrix_ratio)
# end
# # m.ratio(:fixed)
#
# #TODO :  add cell => style, actions, data, content, relation
# #TODO : mega important => I must have a reflection on .value
#
#
# # TODO : try matrix in a matrix's cell
# # TODO : store data, actions, and titles
# # alert m.cell(0)
# # ############################## end table tests #############
# # TODO : alteration data persistence when resizing color, and other particles are lost
#
# # generator = Genesis.generator
# ############
#
# # generator.build_option(:pre_render_parents) do |parents_ids|
# #   parents_ids.each do |parents_id|
# #     parents_found = grab(parents_id)
# #     parents_found.atome[:children] << id if parents_found
# #   end
# #   family(parents_ids)
# # end
# #
# # generator.build_option(:pre_render_children) do |children_pass|
# #   children_pass.each do |child_found|
# #     atome_found = grab(child_found)
# #     atome_found.parents([@atome[:id]])
# #   end
# # end
# #
# # generator.build_particle(:family)
# #
# # generator.build_option(:pre_render_family) do |parents_ids|
# #
# # end
# #
# # ###### render #####
# #
# # generator.build_render(:browser_family) do |parents_found|
# #   parents_found.each do |parent_found|
# #     BrowserHelper.send("browser_attach_#{@browser_type}", parent_found, @browser_object, @atome)
# #   end
# # end
# ############################## new attempt
# #
# # generator.build_sanitizer(:color) do |params|
# #   parent_found = found_parents_and_renderers[:parent]
# #   render_found = found_parents_and_renderers[:renderers]
# #   default_params = { renderers: render_found, id: "color_#{Universe.atomes.length}", type: :color,
# #                      attach: parent_found,children: [],
# #                      red: 0, green: 0, blue: 0, alpha: 1 }
# #   params = create_color_hash(params) unless params.instance_of? Hash
# #   new_params = default_params.merge!(params)
# #   atome[:color] = new_params
# #   new_params
# # end
# #
# # generator.build_option(:pre_render_parents) do |parents_ids|
# #   # family(parents_ids)
# # end
# # generator.build_option(:pre_render_children) do |children_pass|
# #   # children_pass.each do |child_found|
# #   #   atome_found = grab(child_found)
# #   #   atome_found.parents([@atome[:id]])
# #   # end
# # end
# # #  render
# # generator.build_render(:browser_parent) do |parents_found|
# #   # parents_found.each do |parent_found|
# #   #   BrowserHelper.send("browser_attach_#{@browser_type}", parent_found, @browser_object, @atome)
# #   # end
# # end
# #
# # generator.build_render(:browser_children) do |parents_found|
# #   # parents_found.each do |parent_found|
# #   #   BrowserHelper.send("browser_attach_#{@browser_type}", parent_found, @browser_object, @atome)
# #   # end
# # end
#
# ###########  #########
#
# # module BrowserHelper
# #   def self.browser_document
# #     # Work because of the patched version of opal-browser(0.39)
# #     Browser.window
# #   end
# #
# #   def self.browser_attach_div(parents, html_object, _atome)
# #     html_object.append_to(browser_document[parents])
# #   end
# #
# #   def self.browser_attach_style(parents, _html_object, atome)
# #     browser_document[parents].add_class(atome[:id])
# #   end
# # end
#
# # generator.build_option(:pre_render_parents) do |parents_ids|
# #   parents_ids.each do |parents_id|
# #     if parents_id.instance_of? Atome
# #       parents_id = parents_id.value
# #     end
# #     parents_found = grab(parents_id)
# #     family(parents_id)
# #     parents_found.atome[:children] << atome[:id]
# #   end
# # end
# #
# # generator.build_option(:pre_render_children) do |children_ids|
# #   children_ids.each do |child_id|
# #     if child_id.instance_of? Atome
# #       child_id = child_id.value
# #     end
# #     child_found = grab(child_id)
# #     parents_found=@atome[:id]
# #     child_found.family(parents_found)
# #     child_found.atome[:parents] = [parents_found]
# #   end
# # end
# #
#
# # generator.build_particle(:family, { render: true, store: false })
# # generator.build_render(:browser_family) do |parents_found|
# #   BrowserHelper.send("browser_attach_#{@browser_type}", parents_found, @browser_object, @atome)
# # end
#
# # class Universe
# #   def add_to_atomes(id, atome)
# #     # instance_variable_get('@atomes').merge!(atome)
# #     @atomes[id] = atome
# #   end
# #
# #   def update_atome_id(id, atome, prev_id)
# #     puts :ok
# #     @atomes[id] = atome
# #     @atomes.delete(prev_id)
# #   end
# # end
#
# # generator.build_sanitizer(:id) do |params|
# #   if @atome[:id] != params
# #     Universe.update_atome_id(params, self, @atome[:id])
# #   else
# #     Universe.add_to_atomes(params, self)
# #   end
# #   params
# # end
# #
# # generator.build_render(:browser_id) do |params|
# #   browser_object.id = params if @atome[:id] != params
# # end
#
#
#
# # b = box({ id: :titi })
# # c = color(:orange)
# # c.id(:tutu)
# # b.children([:tutu])
#
#
# # alert b.children
# # alert b
# # b.circle({id: :toto})
# # grab(:box_color).parents([:titi])
# # b.children([:box_color])
# # alert b
#
# # generator.build_render(:browser_parents) do |parents_found|
# #   # p :number_parents
# #   # parents_found.each do |parent_found|
# #   #   BrowserHelper.send("browser_attach_#{@browser_type}", parent_found, @browser_object, @atome)
# #   # end
# # end
# #
# # generator.build_render(:browser_children) do |children_found|
# #   # p :number_children
# #   # children_found.each do |child_found|
# #   #   BrowserHelper.send("browser_attach_#{@browser_type}", child_found, @browser_object, @atome)
# #   # end
# # end
#
# # b = box({ id: :the_test_box })
# # i = 0
# # while i < 9
# #   # puts :ok
# #   box({ left: i * 30, width: 9 })
# #   i += 1
# # end
# # # c = color({red: 0, green: 1, blue: 0.3, alpha: 1, id: :thcol, children: []})
# # c = color(:red)
# # # alert a
# # # wait 1 do
# # b.children([c.id])
# # # c.parents([b.id])
# # # puts "box is :\n#{b}\n\n color is :\n#{c}"
# #
# # puts '-----'
# # puts "familly content #{b.family}"
# # # end
#
# # generator.build_option(:pre_render_parents) do |parents_ids|
# #   parents_ids.each do |parents_id|
# #     parents_found = grab(parents_id)
# #     parents_found.atome[:children]<< id if parents_found
# #   end
# #   family({attach: parents_ids, children: [] })
# # end
# #
# #
# # #mess below
# # generator.build_option(:pre_render_children) do |children_ids|
# #   children_ids.each do |child_found|
# #     atome_found = grab(child_found)
# #     atome_found.atome[:parents]=[@atome[:id]]
# #   end
# #   # family({children: children_ids, attach: [] })
# # end
# #
# #
# # generator.build_particle(:family)
# #
# #
# # ####################
# # generator.build_render(:browser_family) do |params|
# #   # puts "kool super kool! : #{parents_found} , type : #{@browser_type}, object : #{@browser_object} ,atome : #{@atome}"
# #   # puts "atome : #{@atome[:id]}, parent  : #{parents_found}}"
# #   # puts "atome : #{@atome} : #{params[:parents]}"
# #   puts " #{params[:parents]}"
# #   parents_found=params[:parents]
# #   children_found=params[:children]
# #   parents_found.each do |parent_found|
# #     # atome=
# #     BrowserHelper.send("browser_attach_#{@browser_type}", parent_found, @browser_object, @atome)
# #   end
# #
# #   children_found.each do |parent_found|
# #     BrowserHelper.send("browser_attach_#{@browser_type}", parent_found, @browser_object, @atome)
# #   end
# #
# # end
# #
# # generator.build_render(:browser_parents) do |parents_found|
# #   # puts "moinskool super kool! : #{parents_found} "
# #   # puts "moinskool super kool! : #{parents_found} , type : #{@browser_type}, object : #{@browser_object} ,atome : #{@atome}"
# #   # parents_found.each do |parent_found|
# #   #   BrowserHelper.send("browser_attach_#{@browser_type}", parent_found, @browser_object, @atome)
# #   # end
# # end
#
# ###################
# # class Atome
# #
# #   def store_value(element)
# #     params=instance_variable_get("@#{element}")
# #     @atome[element] = params
# #   end
# #
# #   def build_particle(particle_name,options,&particle_proc)
# #     type = options[:type]
# #     type = :string if options[:type].nil?
# #     store = options[:store]
# #     store = true if options[:store].nil?
# #     render = options[:render]
# #     render = true if options[:render].nil?
# #
# #     # we add the new method to the particle's collection of methods
# #     Universe.add_to_particle_list(particle_name, type)
# #     auto_render_generator(particle_name) if render #  automatise the creation of an empty render method for current particle
# #     new_particle(particle_name,store,render , &particle_proc)
# #     additional_particle_methods(particle_name, &particle_proc) # create alternative methods such as create 'method='
# #   end
# #
# #   def additional_particle_methods(element, &method_proc)
# #     Atome.define_method "#{element}=" do |params = nil, &user_proc|
# #       instance_exec(params, user_proc, &method_proc) if method_proc.is_a?(Proc)
# #     end
# #   end
# #
# #   def new_particle(element,store,render, &method_proc)
# #     Atome.define_method element do |params = nil, &user_proc|
# #       if params || params == false
# #         # the line below execute the proc created when using the build_particle method
# #         instance_exec(params, user_proc, &method_proc) if method_proc.is_a?(Proc)
# #         params = sanitize(element, params)
# #         create_particle(element,store,render)
# #         send("set_#{element}", params, &user_proc)
# #       else
# #         get_particle(element, &user_proc)
# #       end
# #     end
# #   end
# #   def run_optional_proc(proc_name, atome = self, element, &user_proc)
# #     params=instance_variable_get("@#{element}")
# #     option_found = Universe.get_optional_method(proc_name)
# #     atome.instance_exec(params, user_proc, atome, &option_found) if option_found.is_a?(Proc)
# #   end
# #
# #   def rendering(element, &user_proc)
# #     params=instance_variable_get("@#{element}")
# #     render_engines = @atome[:renderers]
# #     render_engines.each do |render_engine|
# #       send("#{render_engine}_#{element}", params, &user_proc)
# #     end
# #   end
# #
# #   def broadcasting(element)
# #     params=instance_variable_get("@#{element}")
# #     @broadcast.each_value do |particle_monitored|
# #       if particle_monitored[:particles].include?(element)
# #         code_found=particle_monitored[:code]
# #         instance_exec(self, element, params, &code_found) if code_found.is_a?(Proc)
# #       end
# #     end
# #   end
# #
# #   def particle_creation(element, params,store,render, &user_proc)
# #     return false unless security_pass(element, params)
# #     # we create a proc holder of any new particle if user pass a bloc
# #     store_code_bloc(element, &user_proc) if user_proc
# #     # Params is now an instance variable so it should be passed thru different methods
# #     instance_variable_set("@#{element}", params)
# #     run_optional_proc("pre_render_#{@atome[:type]}".to_sym, self, element, &user_proc)
# #     run_optional_proc("pre_render_#{element}".to_sym, self, element, &user_proc)
# #     rendering(element, &user_proc) if render
# #     run_optional_proc("post_render_#{@atome[:type]}".to_sym, self, element, &user_proc)
# #     run_optional_proc("post_render_#{element}".to_sym, self, element, &user_proc)
# #     broadcasting(element)
# #     store_value(element) if store
# #     self
# #   end
# #
# #   def create_particle(element,store,render)
# #     Atome.define_method "set_#{element}" do |params, &user_proc|
# #       particle_creation(element, params, store,render,&user_proc)
# #     end
# #   end
# #
# # end