require "sqlite3"
require "http/server"
require "./guff/*"

module Guff
  class Database < ::SQLite3::Database
    # TODO (add table_exists?)
  end

  class Model
    getter :db

    def initialize(@config : Config)
      # create site database
      db_path = "%s/site.db" % [config["data"]]
      @db = Database.new(db_path)
    end
  end

  class BlogHandler < Handler
    MATCHES = [%r{
      ^/

      # match YYYY/MM/DD/SLUG.html
      (?<year>\d{4})
      /
      (?<month>\d{2})
      /
      (?<day>\d{2})
      /
      (?<slug>[a-z0-9._-]+)
      \.html

      $
    }x, %r{
      ^/

      # match YYYY/MM/DD
      (?<year>\d{4})
      /
      (?<month>\d{2})
      /
      (?<day>\d{2})
      /?

      $
    }x, %r{
      ^/

      # match YYYY/MM
      (?<year>\d{4})
      /
      (?<month>\d{2})
      /?

      $
    }x, %r{
      ^/

      # match YYYY
      (?<year>\d{4})
      /?

      $
    }x, %r{
      # match index
      ^/$
    }x]

    def call(context : HTTP::Server::Context)
      path = context.request.path || ""
      if md = MATCHES.reduce(nil) { |r, m| r || m.match(path) }
        context.response.puts "blog match: %s" % [md.to_s]
      else
        call_next(context)
      end
    end
  end

  class SlugHandler < Handler
    MOCK_SLUGS = {
      "foo": "test slug foo",
      "bar": "test slug bar",
      "baz": "test slug baz",
    }

    RE = Regex.new("^/(?:" + MOCK_SLUGS.keys.join("|") + ").html$")

    def call(context : HTTP::Server::Context)
      if md = RE.match(context.request.path || "")
        context.response.puts "SlugHandler: path = %s, md = %s" % [
          context.request.path,
          md.to_s
        ]
      else
        call_next(context)
      end
    end
  end

  class Server
    def self.run(model : Model, config : Config)
      new(model, config).run
    end

    def initialize(@model : Model, @config : Config)
      # create server
      @server = HTTP::Server.new(
        config["host"],
        config["port"].to_i,
        get_handlers(model, config)
      ) do |context|
        context.response.puts "asdf"
      end
    end

    def run
      puts "listening on %s:%s" % %w{host port}.map { |k| @config[k] }
      @server.listen
    end

    private def get_handlers(
      model : Model,
      config : Config
    ) : Array(HTTP::Handler)
      @handlers ||= [
        HTTP::ErrorHandler.new,
        HTTP::LogHandler.new,
        HTTP::DeflateHandler.new,
        BlogHandler.new(model, config),
        SlugHandler.new(model, config),
        HTTP::StaticFileHandler.new(config["public"]),
      ]
    end
  end

  def self.run(app, args)
    # parse env and cli options
    config = Config.new(app, args)

    # create model
    model = Model.new(config)

    # create server
    Server.run(model, config)
  end
end

Guff.run($0, ARGV)