# encoding: UTF-8
# frozen_string_literal: true

require "memoist"
require "method-not-implemented"
require "json"

module JadePug
  #
  # Abstraction layer for engine compiler.
  #
  class Compiler
    extend Memoist

    #
    # Returns the engine module.
    #
    # Used in such cases:
    # - used to compute the name for engine
    # - used to refer to the error classes
    #
    # @return [Jade, Pug]
    attr_reader :engine

    #
    # Returns the version of engine compiler.
    #
    # @return [String]
    attr_reader :version

    #
    # @param engine [Jade, Pug]
    # @param version [String]
    def initialize(engine, version)
      @engine  = engine
      @version = version
    end

    #
    # Compiles template.
    #
    # By default does nothing.
    #
    # @abstract Derived compilers must implement it.
    # @param source [String, #read]
    #   The template source code or any object which responds to #read and returns string.
    # @param options [Hash]
    # @return [String]
    def compile(source, options = {})
      method_not_implemented
    end

    #
    # Returns true if this compiler is a system compiler.
    # Otherwise returns false.
    #
    # @return [true, false]
    def system?
      SystemCompiler === self
    end

    #
    # Returns true if this compiler is a shipped compiler.
    # Otherwise returns false.
    #
    # @return [true, false]
    def shipped?
      ShippedCompiler === self
    end

  protected

    #
    # Reads the template source code.
    # Responds for pre-processing source code.
    # Actually, it just checks if source code responds to #read and if so
    #
    # @param source [String, #read]
    # @return [String]
    def prepare_source(source)
      source.respond_to?(:read) ? source.read : source
    end

    #
    # Responds for preparing compilation options.
    #
    # The next steps are executed:
    # - is merges options into the engine config
    # - it camelizes and symbolizes every option key
    # - it removes nil values from the options
    #
    # @param options [Hash]
    # @return [Hash]
    def prepare_options(options)
      options = engine.config.to_hash.merge(options)
      options.keys.each { |k| options[k.to_s.gsub(/_([a-z])/) { $1.upcase }.to_sym] = options[k] }
      options.delete_if { |k, v| v.nil? }
    end

    #
    # Generates the JavaScript code that is the bridge
    # from the gem to the template engine compiler.
    #
    # The code responds for:
    # - invoking compiler
    # - rendering template function with given locals
    # - returning the result
    #
    # @param :method [String]
    #   The name of engine method to call.
    # @param :arguments [Array<Object>]
    #   The array of arguments to be passed to the method.
    # @param :locals [Hash]
    #   The hash of template local variables to be used to render template.
    # @param :options [Hash]
    #   The hash of options passed to {#compile}.
    # @return [String]
    def compilation_snippet(args)
      method    = args.fetch(:method)
      arguments = args.fetch(:arguments)
      locals    = args.fetch(:locals)
      options   = args.fetch(:options)

      "        (function() {\n          var engine   = \#{ npm_package_require_snippet };\n          var template = engine[\#{ JSON.dump(method) }].apply(engine, \#{ JSON.dump(arguments) });\n\n          if (typeof template === 'function') {\n            template = template(\#{ JSON.dump(locals) });\n          }\n\n          if (typeof console === 'object' && console !== null && typeof console.log === 'function') {\n            console.log(template);\n          }\n\n          return template;\n        })()\n      JAVASCRIPT\n    end\n\n    #\n    # Returns the JavaScript code used to access engine NPM module.\n    #\n    # @abstract Derived compilers must implement it.\n    # @return [String]\n    def npm_package_require_snippet\n      method_not_implemented\n    end\n\n    #\n    # Responds for post-processing compilation result.\n    #\n    # By default removes leading and trailing whitespace\n    # by calling {String#strip} and returns the result.\n    # Derived compilers may override it for it's own special behavior.\n    #\n    # @param source [String] The source code of template.\n    # @param result [String] The compiled code of template.\n    # @param options [Hash] The compilation options.\n    # @return [String]\n    def process_result(source, result, options)\n      result.strip\n    end\n  end\nend\n"