# frozen_string_literal: true

require 'sinatra/flash'
require 'sinatra/param'

require_relative 'validator'

# Top-level module documentation comment goes here...
module Sinatra
  module Validator
    # Helpers for validating forms
    module Form
      def form_validator(identifier, &block)
        validator = Validator.new(block)
        Sinatra::Validator::Form::ValidateMethods.add identifier, validator
      end

      # Helpers for Sinatra
      module Helpers
        def form_values(hash)
          hash = IndifferentHash[hash]
          flash.now[:params] = flash.now.key?(:params) ? hash.merge(flash.now[:params]) : hash
        end

        def form_value(field)
          flash[:params]&.fetch(field, nil)
        end

        def form_error?(field = nil)
          return !flash[:form_errors].nil? && !flash[:form_errors]&.empty? if field.nil?

          (flash[:form_errors] || {}).key?(field)
        end

        def form_errors(field)
          (flash[:form_errors] || {}).fetch(field, [])
        end

        def validate_form(validator_identifier)
          if validator_identifier.is_a? Symbol
            validator_identifier = Sinatra::Validator::ValidatorIdentifier.new(validator_identifier)
          end
          validate Sinatra::Validator::Form::ValidateMethods.get(validator_identifier.identifier),
                   validator_identifier.args
        end
      end

      # Extend validator to return form errors correctly
      class Validator < Sinatra::Validator::Validator
        def handle_failure
          case @context.request.preferred_type.to_s
          when 'application/json'
            @context.halt 400, { error: 'Validation failed', fields: @errors }.to_json
          when 'text/html'
            @context.flash[:params] = @params
            @context.flash[:form_errors] = @errors
            @context.redirect @context.back
          else
            @context.halt 400
          end
        end
      end

      # Keep hold of the list of valid validator methods
      module ValidateMethods
        @methods = {}

        module_function

        def add(identifier, validator)
          @methods[identifier] = validator
        end

        def get(identifier)
          raise "Unknown validator: '#{identifier}'" unless @methods.key? identifier

          @methods[identifier]
        end
      end

      def self.registered(app)
        app.helpers Helpers

        app.set(:validate_form) do |*identifiers|
          condition do
            filter_params
            identifiers.each { |identifier| validate_form identifier }
          end
        end
      end
    end
  end

  register Sinatra::Validator::Form
end