# Copyright (C) 2012-2026 Zammad Foundation, https://zammad-foundation.org/

class CoreWorkflow < ApplicationModel
  include ChecksClientNotification
  include HasAuditLogs
  include ChecksCoreWorkflow
  include HasSearchIndexBackend
  include CanSelector
  include CanSearch

  include CoreWorkflow::Assets
  include CoreWorkflow::Search

  CUSTOM_MODULE_OPERATORS = ['match all modules', 'match one module', 'match no modules'].freeze

  self.audit_log_attributes_ignored = %i[preferences]

  core_workflow_screens 'create', 'edit'
  core_workflow_permission 'admin.core_workflow'

  default_scope { order(:priority, :id) }
  scope :active, -> { where(active: true) }
  scope :changeable, -> { where(changeable: true) }
  scope :object, ->(object) { where(object: [object, nil]) }

  store :preferences
  store :condition_saved
  store :condition_selected
  store :perform

  validates :name, presence: true, uniqueness: { case_sensitive: false }
  validate :validate_custom_modules

  def self.classes
    Models.all.keys.select { |m| m.include?(ChecksCoreWorkflow) }
  end

  def self.config
    classes.each_with_object({ configuration: {}, execution: {} }) do |config_class, result|
      if config_class.try(:core_workflow_screens).present?
        result[:execution][config_class.to_s] = config_class.try(:core_workflow_screens)
      end
      if config_class.try(:core_workflow_admin_screens).present?
        result[:configuration][config_class.to_s] = config_class.try(:core_workflow_admin_screens)
      end
    end
  end

=begin

Runs the core workflow engine based on the current state of the object.

  perform_result = CoreWorkflow.perform(payload: {
                                          'event'      => 'core_workflow',
                                          'request_id' => 'ChecksCoreWorkflow.validate_workflows',
                                          'class_name' => 'Ticket',
                                          'screen'     => 'edit',
                                          'params'     => Ticket.first.attributes,
                                        }, user: User.find(3), assets: false)

=end

  def self.perform(payload:, user:, assets: {}, assets_in_result: true, result: {}, form_updater: false, policy: true)
    CoreWorkflow::Result.new(payload: payload, user: user, assets: assets, assets_in_result: assets_in_result, result: result, form_updater: form_updater, policy: policy).run
  rescue => e
    return {} if e.is_a?(ArgumentError)
    raise e if !Rails.env.production?

    Rails.logger.error 'Error performing Core Workflow engine.'
    Rails.logger.error e
    {}
  end

=begin

Checks if the object matches a specific condition.

Match saved data:

  CoreWorkflow.matches_selector?(
    id: Ticket.first.id,
    user: User.find_by(login: 'admin@example.com'),
    selector: { 'ticket.state_id'=>{ 'operator' => 'is', 'value' => ['2'] } },
  )

Match payload selected data:

  CoreWorkflow.matches_selector?(
    check: 'selected',
    user: User.find_by(login: 'admin@example.com'),
    params: {
      'group_id'    => '1',
      'owner_id'    => '',
      'state_id'    => '2',
      'priority_id' => '2',
      'article'     => {
        'body'            => '',
        'type'            => 'note',
        'internal'        => true,
        'form_id'         => 'd8416050-0987-4ae4-b36f-c488b3b9b333',
        'shared_draft_id' => '',
        'subtype'         => '',
        'in_reply_to'     => '',
        'to'              => '',
        'cc'              => '',
        'subject'         => ''
      },
    },
    selector: { 'ticket.state_id'=>{ 'operator' => 'is', 'value' => ['2'] } },
  )

=end

  def self.matches_selector?(user:, selector:, id: nil, class_name: 'Ticket', params: {}, screen: 'edit', request_id: 'ChecksCoreWorkflow.validate_workflows', event: 'core_workflow', check: 'saved', policy: false)
    if id.present?
      params['id'] = id
    end

    CoreWorkflow::Result.new(payload: {
                               'event'      => event,
                               'request_id' => request_id,
                               'class_name' => class_name,
                               'screen'     => screen,
                               'params'     => params,
                             }, user: user, assets: false, assets_in_result: false, policy: policy).matches_selector?(selector: selector, check: check)
  rescue => e
    return {} if e.is_a?(ArgumentError)
    raise e if !Rails.env.production?

    Rails.logger.error 'Error performing Core Workflow engine.'
    Rails.logger.error e
    false
  end

  private

  def validate_custom_modules
    custom_module_paths.each do |module_path|
      next if CoreWorkflow::Custom.lookup(module_path)

      errors.add(:base, format(__("Custom module '%s' is not available."), module_path))
    end
  end

  def custom_module_paths
    Array(perform.dig('custom.module', 'execute')) + condition_module_paths
  end

  def condition_module_paths
    [condition_saved, condition_selected].flat_map(&:values).flat_map do |condition|
      next [] if CUSTOM_MODULE_OPERATORS.exclude?(condition['operator'])

      Array.wrap(condition['value']).map { |value| value.is_a?(Hash) ? value['value'] : value }
    end
  end
end
