require 'sinatra/base'
require 'sendgrid-ruby'
require 'redis'
require 'json'

require_relative 'models'
require_relative 'akismet'

module Cachai

  class Middleware < Sinatra::Base

    # set :database_file, "config/database.yml"
    # set :public_folder, File.join(settings.root, 'public')
    # set :protection, true
    # set :logging, nil

    # use Rack::CommonLogger, LOGGER
    # use Rack::Static, :urls => %w(/css /img /js /favicon.ico), :root => 'public'
    use ActiveRecord::ConnectionAdapters::ConnectionManagement

    CACHE_MINUTES = 10 * 60 # 10 minutes

    def initialize(app, opts = nil)
      opts = opts || {}
      domain     = opts.delete(:domain) or raise 'Domain required.'
      redis_host = opts.delete(:redis_host) || 'localhost'

      Cachai.domain = domain
      Cachai.cache = Redis.new(:host => redis_host)
      Cachai.load_db!

      if key = opts.delete(:akismet_key)
        @akismet = Akismet.new(:api_key => key, :blog => "http://#{domain}")
      else
        puts "No Akismet key found! Will not check comments for spam."
      end

      if sendgrid_opts = opts.delete(:sendgrid)
        @sendgrid  = SendGrid::Client.new(sendgrid_opts)
        @recipient = opts.delete(:recipient) or raise "No recipient set!"
      end

      super(app)
    end

    get '/pingbacks.?:format?' do
      # TODO
    end

    post '/pingbacks.?:format?' do
      # TODO
    end

    get '/comments.?:format?' do
      check_domain!(params[:domain])

      # puts "Comments for: #{params[:domain]}#{params[:path]}"
      json_list = get_comments(params[:path], params[:nocache])

      if params[:callback]
        content_type 'application/javascript'
        "#{params[:callback]}(#{json_list});"
      else
        json(json_list)
      end
    end

    post '/comments.?:format?' do
      begin
        data = JSON.parse(request.body.read)
        check_domain!(data['domain'])

        halt(400, "Missing params") if data['protocol'].blank? or data['path'].blank?

        headers['Access-Control-Allow-Origin'] = data['protocol'] + '//' + data['domain']
        permalink = 'http://' + data['domain'] + data['path']
        halt(400, "No spam allowed") if is_spam?(data, permalink, request)

        attrs = {
          :content      => data['content'],
          :author_name  => data['author_name'],
          :author_email => data['author_email'],
          :author_url   => data['author_url'],
          :parent_id    => data['parent_id'].to_i,
          :author_ip    => request.ip
        }

        post = Post.find_or_create_by_path(data['path'])
        response = Response.create!(attrs.merge(:post_id => post.id))
        Cachai.clear_cache(data['path'])
        notify_new_response(response, data['path'])

        json({ :status => 'ok', :comment => response })

      rescue JSON::ParserError
        status 400 and json({ :error => 'Invalid JSON.' })
      rescue ActiveRecord::RecordInvalid => e
        status 422 and json({ :error => e.message })
      rescue => e
        puts e.message
        puts e.backtrace.join("\n")
        status 500 and "Something went wrong."
      end
    end

    private

=begin
    def set_cache(timestamp)
      return if timestamp.nil?
      last_modified timestamp
      cache_control :public, :must_revalidate, :max_age => 60
    end

    def prevent_cache
      cache_control :public, :no_cache, :no_store, :must_revalidate, :max_age => 0
      # expires 1.year.ago
    end
=end

    def check_domain!(domain)
      halt(400, 'Invalid domain.') unless domain == Cachai.domain
    end

    def not_found(message = nil)
      halt(404, message || 'Not found.')
    end

    def json(obj)
      content_type 'application/json'
      return obj.is_a?(String) ? obj : obj.to_json
    end

    def get_comments(path, nocache = false)
      key = Cachai.key_for(path)

      unless !nocache && json_list = Cachai.cache.get(key)
        puts "Not cached. Getting from DB: #{path}"

        if post = Post.find_by_path(path)
          json_list = get_and_sort_comments_for(post).to_json
        else
          json_list = '[]'
        end

        Cachai.cache.set(key, json_list)
        Cachai.cache.expire(key, CACHE_MINUTES)
      end

      json_list
    end

    def get_and_sort_comments_for(post)
      result = []
      top_level = post.responses.comment.approved.top_level
      nested    = post.responses.comment.approved.nested

      top_level.each_with_index do |comment, i|
        obj = comment.as_json
        children = nested.select do |nested|
          nested.parent_id == comment.id
        end
        obj.merge!(:children => children) if children.any?
        result.push(obj)
      end

      result
    end

    def is_spam?(data, link, request)
      return false unless @akismet
      # return true if blacklisted?(name, email, content)

      comment = {
        :user_ip              => request.ip,
        :referrer             => request.referrer,
        :user_agent           => request.user_agent,
        :permalink            => link,
        :comment_type         => 'comment',
        :comment_content      => data['content'],
        :comment_author       => data['author_name'],
        :comment_author_url   => data['author_url'],
        :comment_author_email => data['author_email']
      }

      if resp = @akismet.check_comment(comment)
        # puts resp.inspect
        return resp[:spam]
      end

      false
    end

    def notify_new_response(response, path)
      mail = SendGrid::Mail.new do |m|
        m.to       = @recipient
        m.from     = 'comments@' + Cachai.domain
        m.reply_to = response.author_email
        m.subject  = "New comment from #{response.author_name} at #{path}"
        m.text     = "#{response.content}\n\n--\nhttp://#{Cachai.domain}/#{path}"
      end

      puts @sendgrid.send(mail)
    rescue SendGrid::Exception => e
      puts e.inspect
    end

  end

end