#! /usr/bin/env ruby

begin
  require 'simplecov'
  SimpleCov.start do
    add_filter 'spec'
  end
rescue LoadError
end

begin
  require 'coveralls'
  SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter.new [
    SimpleCov::Formatter::HTMLFormatter,
    Coveralls::SimpleCov::Formatter
  ]
rescue LoadError
end

require 'yaml'

require 'zorglub'
require 'zorglub/engines/file'
require 'zorglub/engines/haml'
require 'zorglub/engines/sass'

HASH_PROC = proc { |path, obj| { path: path, layout: obj.layout, view: obj.view, args: obj.args, map: obj.map }.to_yaml }
STATIC_PROC = proc { |_path, obj| ["VAL #{obj.value}", 'text/static'] }
RENDER_PROC = proc { |_path, obj|
  case obj.state
  when :layout
    "layout_start #{obj.content} layout_end"
  when :view
    ['view_content', 'text/view']
  when :partial
    ['partial_content', 'text/partial']
  else
    raise Exception.new
  end
}
APP_ROOT = File.join Dir.pwd, 'spec', 'data'

class Zorglub::Node
  def self.my_call(uri)
    call({ 'PATH_INFO' => uri })
  end

  def self.my_call_i(uri)
    call({ 'PATH_INFO' => uri }).body[0].to_i
  end
end

class Temp < Zorglub::Node
end

class Node0 < Zorglub::Node
  # default
  def index
    html
  end

  def hello
    no_layout!
    'world'
  end

  def with_2args(arg1, arg2); end

  def do_render
    engine! 'real'
  end

  def do_content_type
    engine! 'real'
    response.headers['Content-Type'] = 'text/mine'
  end

  def do_partial(_arg1, _arg2)
    engine! 'real'
  end

  def other_view
    engine! 'real'
    view! r('do_partial')
  end

  def do_redirect
    redirect r(:do_partial, 1, 2, 3)
  end

  def xml_file
    no_layout!
    engine! :file
    ext! 'xml'
    mime! 'application/xml'
  end

  def plain_file
    no_layout!
    engine! :file
    ext! 'txt'
    mime! 'text/plain'
  end

  def no_view_no_layout
    no_view!
    no_layout!
    'hello world'
  end

  def engines(name)
    no_layout!
    case name
    when 'haml'
      engine! :haml
    when 'sass'
      engine! :sass
    end
  end
end

class Node1 < Zorglub::Node
  layout! 'layout-1'
  engine! 'engine-1'
  def index
    layout! 'main'
    engine! 'engine-2'
  end
end

class Node2 < Node1
  # inherited from Node1
end

class Node3 < Zorglub::Node
  @before = 0
  @after = 0
  class << self
    attr_accessor :before, :after

    def post(_obj)
      @after += 1
    end
  end
  before_all do |_node|
    Node3.before += 1
  end
  after_all Node3.method(:post)
  layout! 'layout-2'
  engine! 'engine-2'
  def index
    Node3.before - Node3.after
  end

  def do_partial(_arg1, _arg2)
    view! Node0.r('do_partial')
    engine! 'real'
  end
end

class Node8 < Node3
end

class Node4 < Zorglub::Node
  no_layout!
  cli_val :js, 'js0'
  cli_val :js, 'js1'

  def index
    cli_val(:js).to_yaml
  end

  def more
    cli_val :js, 'js2'
    cli_val(:js).to_yaml
  end
end

class Node5 < Node4
  cli_val :js, 'js3'
  cli_val :css, 'css0', 'css1'
  # no_layout! inherited from Node4
  def index
    js = cli_val(:js, 'jsx')
    cli_val(:css, 'css0', 'css1', 'css2')
    css = cli_val :css
    js.concat(css).to_yaml
  end
end

class Node6 < Zorglub::Node
  @static_cpt = 0
  class << self
    attr_accessor :static_cpt
  end
  attr_reader :value

  static! true, 5
  def no_static
    static! false
    engine! 'static'
    view! Node0.r('do_render')
    Node6.static_cpt += 1
    @value = Node6.static_cpt
  end

  def do_static
    engine! 'static'
    view! Node0.r('do_render')
    Node6.static_cpt += 1
    @value = Node6.static_cpt
  end
end

class Node7 < Zorglub::Node
  layout_base_path! File.join APP_ROOT, 'alt', 'layout'
  view_base_path! File.join APP_ROOT, 'alt'
  def view_path
    view! 'do_render'
  end
end

APP = Zorglub::App.new do
  register_engine! :file, nil, Zorglub::Engines::File.method(:proc)
  register_engine! :haml, 'haml', Zorglub::Engines::Haml.method(:proc)
  register_engine! :sass, 'scss', Zorglub::Engines::Sass.method(:proc)
  register_engine! 'default', nil, HASH_PROC
  register_engine! 'engine-1', 'spec', HASH_PROC
  register_engine! 'engine-2', 'spec', HASH_PROC
  register_engine! 'real', nil, RENDER_PROC
  register_engine! 'static', nil, STATIC_PROC
  opt! :root, APP_ROOT
  opt! :engine, 'default'
  map '/node0', Node0
  map '/node1', Node1
  map '/node3', Node3
  map '/node4', Node4
  map '/node5', Node5
  map '/node6', Node6
  map '/node7', Node7
  map '/node8', Node8
end

class Node2
  map APP, '/node2'
end