require "spec"
require "../src/ameba"

module Ameba
  # Dummy Rule which does nothing.
  struct DummyRule < Rule::Base
    properties do
      description : String = "Dummy rule that does nothing."
    end

    def test(source)
    end
  end

  class Source
    def initialize(code : String, @path = "", normalize = true)
      @code = normalize ? normalize_source(code) : code
    end

    private def normalize_source(code, separator = "\n")
      lines = code.split(separator)

      # remove unneeded first and last blank lines if any
      lines.shift if lines[0].blank? && lines.size > 1
      lines.pop if lines[-1].blank? && lines.size > 1

      # find the minimum indentation
      min_indent = lines.min_of do |line|
        line.blank? ? code.size : line.size - line.lstrip.size
      end

      # remove the width of minimum indentation in each line
      lines
        .map! { |line| line.blank? ? line : line[min_indent..-1] }
        .join(separator)
    end
  end

  struct NamedRule < Rule::Base
    properties do
      description : String = "A rule with a custom name."
    end

    def test(source)
    end

    def self.name
      "BreakingRule"
    end
  end

  struct ErrorRule < Rule::Base
    properties do
      description : String = "Always adds an error at 1:1"
    end

    def test(source)
      issue_for({1, 1}, "This rule always adds an error")
    end
  end

  struct ScopeRule < Rule::Base
    getter scopes = [] of AST::Scope

    def test(source)
    end

    def test(source, node : Crystal::ASTNode, scope : AST::Scope)
      @scopes << scope
    end
  end

  struct FlowExpressionRule < Rule::Base
    getter expressions = [] of AST::FlowExpression

    def test(source)
    end

    def test(source, node, flow_expression : AST::FlowExpression)
      @expressions << flow_expression
    end
  end

  struct RedundantControlExpressionRule < Rule::Base
    getter nodes = [] of Crystal::ASTNode

    def test(source)
    end

    def test(source, node, visitor : AST::RedundantControlExpressionVisitor)
      nodes << node
    end
  end

  # A rule that always raises an error
  struct RaiseRule < Rule::Base
    property should_raise = false

    def test(source)
      should_raise && raise "something went wrong"
    end
  end

  class DummyFormatter < Formatter::BaseFormatter
    property started_sources : Array(Source)?
    property finished_sources : Array(Source)?
    property started_source : Source?
    property finished_source : Source?

    def started(sources)
      @started_sources = sources
    end

    def source_finished(source : Source)
      @started_source = source
    end

    def source_started(source : Source)
      @finished_source = source
    end

    def finished(sources)
      @finished_sources = sources
    end
  end

  struct BeValidExpectation
    def match(source)
      source.valid?
    end

    def failure_message(source)
      String.build do |str|
        str << "Source expected to be valid, but there are issues: \n\n"
        source.issues.reject(&.disabled?).each do |e|
          str << "  * #{e.rule.name}: #{e.message}\n"
        end
      end
    end

    def negative_failure_message(source)
      "Source expected to be invalid, but it is valid."
    end
  end

  class TestNodeVisitor < Crystal::Visitor
    NODES = [
      Crystal::Var,
      Crystal::Assign,
      Crystal::OpAssign,
      Crystal::MultiAssign,
      Crystal::Block,
      Crystal::Macro,
      Crystal::Def,
      Crystal::If,
      Crystal::While,
      Crystal::MacroLiteral,
      Crystal::Expressions,
      Crystal::ControlExpression,
    ]

    def initialize(node)
      node.accept self
    end

    def visit(node : Crystal::ASTNode)
      true
    end

    {% for node in NODES %}
      {{getter_name = node.stringify.split("::").last.underscore + "_nodes"}}

      getter {{getter_name.id}} = [] of {{node}}

      def visit(node : {{node}})
        {{getter_name.id}} << node
        true
      end
    {% end %}
  end
end

def be_valid
  Ameba::BeValidExpectation.new
end

def as_node(source)
  Crystal::Parser.new(source).parse
end

def as_nodes(source)
  Ameba::TestNodeVisitor.new(as_node source)
end