class CreateObjectives < ActiveRecord::Migration[8.1]
  def change
    create_table :objectives do |t|
      t.string  :title,               null: false
      t.text    :description
      t.string  :status,              null: false, default: "draft"
      t.integer :progress_pct,        null: false, default: 0
      t.references :owner,            null: false, foreign_key: { to_table: :users }
      t.date    :starts_on,           null: false
      t.date    :ends_on,             null: false
      t.string  :quarter                        # e.g. "Q1 2026"
      t.text    :stakeholder_emails             # comma-separated, simple
      t.timestamps
    end

    add_index :objectives, :status
    add_index :objectives, :quarter

    create_table :key_results do |t|
      t.references :objective,        null: false, foreign_key: true
      t.string  :title,               null: false
      t.decimal :target_value,        precision: 12, scale: 2
      t.decimal :current_value,       precision: 12, scale: 2, default: 0
      t.string  :unit                           # "revenue ($)", "contracts", "%"
      t.string  :status,              null: false, default: "active"
      t.timestamps
    end
  end
end

class CreatePayRuns < ActiveRecord::Migration[8.1]
  def change
    create_table :pay_runs do |t|
      t.string  :period_label,        null: false   # "March 2026"
      t.date    :pay_date,            null: false
      t.string  :status,              null: false, default: "draft"
      t.references :submitted_by_user, foreign_key: { to_table: :users }
      t.references :approved_by_user,  foreign_key: { to_table: :users }
      t.integer :total_amount_cents,  null: false, default: 0
      t.text    :notes
      t.timestamps
    end

    add_index :pay_runs, :status
    add_index :pay_runs, :period_label

    create_table :pay_items do |t|
      t.references :pay_run,          null: false, foreign_key: true
      t.references :user,             null: false, foreign_key: true
      t.integer :gross_amount_cents,  null: false, default: 0
      t.integer :net_amount_cents,    null: false, default: 0
      t.string  :description                        # "Base salary", "Bonus"
      t.timestamps
    end
  end
end

class CreateFeedbackTickets < ActiveRecord::Migration[8.1]
  def change
    create_table :feedback_tickets do |t|
      t.string  :title,             null: false
      t.text    :description,       null: false
      t.string  :status,            null: false, default: "reported"
      t.string  :category                        # "bug", "feature", "ux", "performance"
      t.string  :priority                        # "low", "medium", "high", "critical"
      t.references :reporter,       null: false, foreign_key: { to_table: :users }
      t.references :assignee,       foreign_key: { to_table: :users }
      t.datetime :resolved_at
      t.text    :wontfix_reason
      t.timestamps
    end

    add_index :feedback_tickets, :status
    add_index :feedback_tickets, :category
    add_index :feedback_tickets, :priority
  end
end

# frozen_string_literal: true

class Objective < ApplicationRecord
  include Fosm::Lifecycle

  belongs_to :owner, class_name: "User"
  has_many   :key_results, dependent: :destroy
  accepts_nested_attributes_for :key_results, allow_destroy: true,
                                              reject_if: :all_blank

  validates :title,      presence: true
  validates :starts_on,  presence: true
  validates :ends_on,    presence: true
  validate  :ends_after_starts

  # Based on Parolkar's FOSM paper: https://www.parolkar.com/fosm
  enum :status, {
    draft:     "draft",
    active:    "active",
    at_risk:   "at_risk",
    completed: "completed",
    abandoned: "abandoned"
  }, default: :draft

  lifecycle do
    state :draft,     label: "Draft",     color: "slate",  initial: true
    state :active,    label: "Active",    color: "blue"
    state :at_risk,   label: "At Risk",   color: "amber"
    state :completed, label: "Completed", color: "green",  terminal: true
    state :abandoned, label: "Abandoned", color: "red",    terminal: true

    event :activate,      from: :draft,                       to: :active,    label: "Activate"
    event :flag_at_risk,  from: :active,                      to: :at_risk,   label: "Flag At Risk"
    event :recover,       from: :at_risk,                     to: :active,    label: "Recover"
    event :complete,      from: [:active, :at_risk],          to: :completed, label: "Complete"
    event :abandon,       from: [:draft, :active, :at_risk],  to: :abandoned, label: "Abandon"

    actors :human, :system

    # Guards
    guard :has_key_results, on: :activate,
          description: "Must have at least one key result defined" do |obj|
      obj.key_results.where.not(status: "deleted").count >= 1
    end

    guard :has_progress, on: :complete,
          description: "Progress must be greater than 0 to complete" do |obj|
      obj.progress_pct > 0
    end

    # Side effects
    side_effect :notify_stakeholders_at_risk, on: :flag_at_risk,
                description: "Email stakeholders when objective goes at-risk" do |obj, _t|
      emails = obj.stakeholder_emails&.split(",")&.map(&:strip)&.compact || []
      ObjectiveMailer.at_risk_notification(obj, emails).deliver_later if emails.any?
    end

    side_effect :celebrate_completion, on: :complete,
                description: "Post completion to activity feed" do |obj, _t|
      ActivityFeed.post!(
        actor:   obj.owner,
        action:  "completed_objective",
        subject: obj,
        message: "Objective '#{obj.title}' marked complete at #{obj.progress_pct}% progress."
      )
    end
  end

  scope :in_quarter,    ->(q)    { where(quarter: q) }
  scope :current,       ->       { where(ends_on: Date.current..) }
  scope :needs_review,  ->       { where(status: :at_risk) }

  def progress_from_key_results
    return 0 if key_results.empty?
    krs = key_results.to_a
    return 0 if krs.all? { |kr| kr.target_value.to_f.zero? }
    pcts = krs.map { |kr| [(kr.current_value.to_f / kr.target_value.to_f * 100).round, 100].min }
    (pcts.sum.to_f / pcts.size).round
  end

  def sync_progress!
    update!(progress_pct: progress_from_key_results)
  end

  private

  def ends_after_starts
    return unless starts_on && ends_on
    errors.add(:ends_on, "must be after start date") if ends_on <= starts_on
  end
end

# frozen_string_literal: true

class PayRun < ApplicationRecord
  include Fosm::Lifecycle

  belongs_to :submitted_by_user, class_name: "User", optional: true
  belongs_to :approved_by_user,  class_name: "User", optional: true
  has_many   :pay_items,         dependent: :destroy
  accepts_nested_attributes_for :pay_items, allow_destroy: true,
                                            reject_if: :all_blank

  validates :period_label, presence: true
  validates :pay_date,     presence: true

  # Based on Parolkar's FOSM paper: https://www.parolkar.com/fosm
  enum :status, {
    draft:     "draft",
    submitted: "submitted",
    approved:  "approved",
    paid:      "paid",
    voided:    "voided"
  }, default: :draft

  lifecycle do
    state :draft,     label: "Draft",     color: "slate",  initial: true
    state :submitted, label: "Submitted", color: "blue"
    state :approved,  label: "Approved",  color: "amber"
    state :paid,      label: "Paid",      color: "green",  terminal: true
    state :voided,    label: "Voided",    color: "red",    terminal: true

    event :submit, from: :draft,      to: :submitted, label: "Submit for Approval"
    event :approve, from: :submitted, to: :approved,  label: "Approve"
    event :pay,    from: :approved,   to: :paid,      label: "Mark Paid"
    event :void,   from: [:draft, :submitted, :approved], to: :voided, label: "Void"

    actors :human

    # Guards — financial controls
    guard :has_pay_items, on: :submit,
          description: "Pay run must have at least one pay item" do |pr|
      pr.pay_items.count >= 1
    end

    guard :not_own_pay_run, on: :approve,
          description: "Cannot approve a pay run you submitted" do |pr, actor:|
      actor.nil? || pr.submitted_by_user_id != actor.id
    end

    guard :sufficient_total, on: :pay,
          description: "Pay run total must be greater than zero" do |pr|
      pr.total_amount_cents > 0
    end

    # Side effects
    side_effect :generate_pay_slips, on: :pay,
                description: "Generate and email pay slips to each employee" do |pr, _t|
      pr.pay_items.each do |item|
        PayRunMailer.pay_slip(pr, item).deliver_later
      end
    end

    side_effect :notify_finance_submitted, on: :submit,
                description: "Notify finance team when pay run is submitted" do |pr, _t|
      User.finance_admins.each do |admin|
        PayRunMailer.submitted_notification(pr, admin).deliver_later
      end
    end
  end

  scope :pending_approval, -> { where(status: :submitted) }
  scope :for_period,       ->(label) { where(period_label: label) }

  def recalculate_total!
    update!(total_amount_cents: pay_items.sum(:gross_amount_cents))
  end

  def total_amount
    Money.new(total_amount_cents)
  end
end

# frozen_string_literal: true

class FeedbackTicket < ApplicationRecord
  include Fosm::Lifecycle

  belongs_to :reporter,  class_name: "User"
  belongs_to :assignee,  class_name: "User", optional: true

  validates :title,       presence: true
  validates :description, presence: true

  # Based on Parolkar's FOSM paper: https://www.parolkar.com/fosm
  enum :status, {
    reported:    "reported",
    triaged:     "triaged",
    planned:     "planned",
    in_progress: "in_progress",
    resolved:    "resolved",
    wontfix:     "wontfix"
  }, default: :reported

  CATEGORIES  = %w[bug feature ux performance infrastructure other].freeze
  PRIORITIES  = %w[low medium high critical].freeze

  validates :category, inclusion: { in: CATEGORIES }, allow_blank: true
  validates :priority, inclusion: { in: PRIORITIES }, allow_blank: true

  lifecycle do
    state :reported,    label: "Reported",     color: "slate",  initial: true
    state :triaged,     label: "Triaged",      color: "blue"
    state :planned,     label: "Planned",      color: "violet"
    state :in_progress, label: "In Progress",  color: "amber"
    state :resolved,    label: "Resolved",     color: "green",  terminal: true
    state :wontfix,     label: "Won't Fix",    color: "gray",   terminal: true

    event :triage,       from: :reported,    to: :triaged,     label: "Triage"
    event :plan,         from: :triaged,     to: :planned,     label: "Plan"
    event :start_work,   from: :planned,     to: :in_progress, label: "Start Work"
    event :resolve,      from: :in_progress, to: :resolved,    label: "Resolve"
    event :mark_wontfix, from: [:reported, :triaged, :planned, :in_progress],
                         to: :wontfix, label: "Won't Fix"

    actors :human, :system

    # Guards
    guard :has_category, on: :triage,
          description: "Category must be assigned before triage" do |t|
      t.category.present?
    end

    guard :has_assignee, on: :plan,
          description: "Assignee must be set before planning" do |t|
      t.assignee.present?
    end

    # Side effects
    side_effect :notify_reporter_resolved, on: :resolve,
                description: "Email reporter when ticket is resolved" do |ticket, _t|
      FeedbackMailer.resolved_notification(ticket).deliver_later
      ticket.update!(resolved_at: Time.current)
    end

    side_effect :update_analytics_on_triage, on: :triage,
                description: "Update analytics counters by category" do |ticket, _t|
      AnalyticsCounter.increment!("feedback_triaged", by_category: ticket.category)
    end
  end

  scope :open,           -> { where.not(status: [:resolved, :wontfix]) }
  scope :by_category,    ->(cat) { where(category: cat) }
  scope :by_priority,    ->(pri) { where(priority: pri) }
  scope :auto_generated, -> { where("title LIKE ?", "[Auto]%") }

  # Class method — called by BehaviourAnalytics job (see Chapter 5)
  def self.create_from_behaviour_event!(event_data)
    create!(
      title:       "[Auto] #{event_data[:title]}",
      description: event_data[:description],
      reporter:    User.system_user,
      category:    event_data[:category] || "bug",
      priority:    event_data[:priority] || "medium"
    )
  end
end

# frozen_string_literal: true

class ObjectivesController < ApplicationController
  before_action :authenticate_user!
  before_action :set_objective, only: %i[show edit update destroy activate
                                          flag_at_risk recover complete abandon]

  def index
    @objectives = Objective.includes(:owner, :key_results)
                            .order(ends_on: :asc)
    @objectives = @objectives.in_quarter(params[:quarter]) if params[:quarter].present?
    @objectives = @objectives.where(status: params[:status])  if params[:status].present?
    @quarters   = Objective.distinct.pluck(:quarter).compact.sort.reverse
  end

  def show
    @key_results = @objective.key_results.order(:title)
    @history     = @objective.lifecycle_history
  end

  def create
    @objective = Objective.new(objective_params)
    @objective.owner = current_user
    if @objective.save
      redirect_to @objective, notice: "Objective created."
    else
      render :new, status: :unprocessable_entity
    end
  end

  # ── Transition actions ─────────────────────────────────────────────────────

  def activate
    @objective.transition!(:activate, actor: current_user)
    redirect_to @objective, notice: "Objective activated."
  rescue Fosm::TransitionService::GuardFailed => e
    redirect_to @objective, alert: "Cannot activate: #{e.message}"
  end

  def flag_at_risk
    @objective.transition!(:flag_at_risk, actor: current_user)
    redirect_to @objective, notice: "Objective flagged as at-risk. Stakeholders notified."
  end

  def recover
    @objective.transition!(:recover, actor: current_user)
    redirect_to @objective, notice: "Objective recovered to active."
  end

  def complete
    @objective.sync_progress!
    @objective.transition!(:complete, actor: current_user)
    redirect_to @objective, notice: "Objective marked complete. Well done."
  rescue Fosm::TransitionService::GuardFailed => e
    redirect_to @objective, alert: "Cannot complete: #{e.message}"
  end

  def abandon
    @objective.transition!(:abandon, actor: current_user)
    redirect_to @objective, notice: "Objective abandoned."
  end

  private

  def set_objective
    @objective = Objective.find(params[:id])
  end

  def objective_params
    params.require(:objective).permit(
      :title, :description, :starts_on, :ends_on, :quarter, :stakeholder_emails,
      key_results_attributes: [:id, :title, :target_value, :current_value, :unit, :_destroy]
    )
  end
end

# frozen_string_literal: true

class PayRunsController < ApplicationController
  before_action :authenticate_user!
  before_action :set_pay_run, only: %i[show edit update destroy submit approve pay void]

  def index
    @pay_runs = PayRun.includes(:submitted_by_user, :approved_by_user, :pay_items)
                      .order(pay_date: :desc)
    @pay_runs = @pay_runs.where(status: params[:status]) if params[:status].present?
  end

  def create
    @pay_run = PayRun.new(pay_run_params)
    if @pay_run.save
      @pay_run.recalculate_total!
      redirect_to @pay_run, notice: "Pay run created."
    else
      render :new, status: :unprocessable_entity
    end
  end

  # ── Transition actions ─────────────────────────────────────────────────────

  def submit
    @pay_run.recalculate_total!
    @pay_run.submitted_by_user = current_user
    @pay_run.save!
    @pay_run.transition!(:submit, actor: current_user)
    redirect_to @pay_run, notice: "Pay run submitted for approval."
  rescue Fosm::TransitionService::GuardFailed => e
    redirect_to @pay_run, alert: "Cannot submit: #{e.message}"
  end

  def approve
    @pay_run.approved_by_user = current_user
    @pay_run.save!
    @pay_run.transition!(:approve, actor: current_user)
    redirect_to @pay_run, notice: "Pay run approved."
  rescue Fosm::TransitionService::GuardFailed => e
    redirect_to @pay_run, alert: "Cannot approve: #{e.message}"
  end

  def pay
    @pay_run.transition!(:pay, actor: current_user)
    redirect_to @pay_run, notice: "Pay run marked as paid. Pay slips generated."
  rescue Fosm::TransitionService::GuardFailed => e
    redirect_to @pay_run, alert: "Cannot mark paid: #{e.message}"
  end

  def void
    @pay_run.transition!(:void, actor: current_user)
    redirect_to @pay_run, notice: "Pay run voided."
  end

  private

  def set_pay_run
    @pay_run = PayRun.find(params[:id])
  end

  def pay_run_params
    params.require(:pay_run).permit(
      :period_label, :pay_date, :notes,
      pay_items_attributes: [:id, :user_id, :gross_amount_cents, :net_amount_cents, :description, :_destroy]
    )
  end
end

# frozen_string_literal: true

class FeedbackTicketsController < ApplicationController
  before_action :authenticate_user!
  before_action :set_ticket, only: %i[show edit update triage plan start_work resolve mark_wontfix]

  def index
    @tickets = FeedbackTicket.includes(:reporter, :assignee)
                              .order(created_at: :desc)
    @tickets = @tickets.where(status: params[:status])   if params[:status].present?
    @tickets = @tickets.by_category(params[:category])   if params[:category].present?
    @tickets = @tickets.by_priority(params[:priority])   if params[:priority].present?
  end

  def create
    @ticket = FeedbackTicket.new(ticket_params)
    @ticket.reporter = current_user
    if @ticket.save
      redirect_to @ticket, notice: "Feedback ticket created."
    else
      render :new, status: :unprocessable_entity
    end
  end

  # ── Transition actions ─────────────────────────────────────────────────────

  def triage
    @ticket.assign_attributes(ticket_params.slice(:category, :priority))
    @ticket.save!
    @ticket.transition!(:triage, actor: current_user)
    redirect_to @ticket, notice: "Ticket triaged."
  rescue Fosm::TransitionService::GuardFailed => e
    redirect_to @ticket, alert: "Cannot triage: #{e.message}"
  end

  def plan
    @ticket.assign_attributes(ticket_params.slice(:assignee_id))
    @ticket.save!
    @ticket.transition!(:plan, actor: current_user)
    redirect_to @ticket, notice: "Ticket planned and assigned."
  rescue Fosm::TransitionService::GuardFailed => e
    redirect_to @ticket, alert: "Cannot plan: #{e.message}"
  end

  def start_work
    @ticket.transition!(:start_work, actor: current_user)
    redirect_to @ticket, notice: "Work started."
  end

  def resolve
    @ticket.transition!(:resolve, actor: current_user)
    redirect_to @ticket, notice: "Ticket resolved. Reporter notified."
  end

  def mark_wontfix
    reason = params[:wontfix_reason].presence || "No reason given"
    @ticket.update!(wontfix_reason: reason)
    @ticket.transition!(:mark_wontfix, actor: current_user)
    redirect_to @ticket, notice: "Ticket marked as won't fix."
  end

  private

  def set_ticket
    @ticket = FeedbackTicket.find(params[:id])
  end

  def ticket_params
    params.require(:feedback_ticket).permit(
      :title, :description, :category, :priority, :assignee_id, :wontfix_reason
    )
  end
end

resources :objectives do
  member do
    post :activate
    post :flag_at_risk
    post :recover
    post :complete
    post :abandon
  end
end

resources :pay_runs do
  member do
    post :submit
    post :approve
    post :pay
    post :void
  end
end

resources :feedback_tickets do
  member do
    post :triage
    post :plan
    post :start_work
    post :resolve
    post :mark_wontfix
  end
end

# frozen_string_literal: true

class DashboardsController < ApplicationController
  before_action :authenticate_user!

  def strategic
    # OKR Health
    @okr_distribution   = FosmTransition.state_distribution("Objective")
    @okr_at_risk_count  = Objective.where(status: :at_risk).count
    @okr_this_quarter   = Objective.in_quarter(current_quarter).count
    @okr_completed_rate = begin
      completed = @okr_distribution["completed"].to_f
      total     = @okr_distribution.values.sum.to_f
      total > 0 ? (completed / total * 100).round : 0
    end

    # Payroll status
    @payroll_distribution    = FosmTransition.state_distribution("PayRun")
    @pending_approval_count  = PayRun.pending_approval.count
    @last_paid_run           = PayRun.where(status: :paid).order(pay_date: :desc).first

    # Feedback pipeline
    @feedback_distribution   = FosmTransition.state_distribution("FeedbackTicket")
    @critical_open_count     = FeedbackTicket.open.by_priority("critical").count
    @avg_time_in_reported    = FosmTransition.avg_time_in_state("FeedbackTicket", :reported)
    @avg_time_in_triaged     = FosmTransition.avg_time_in_state("FeedbackTicket", :triaged)
    @avg_time_in_planned     = FosmTransition.avg_time_in_state("FeedbackTicket", :planned)
    @avg_time_in_progress    = FosmTransition.avg_time_in_state("FeedbackTicket", :in_progress)

    # Auto-generated tickets (from BehaviourAnalytics)
    @auto_ticket_count       = FeedbackTicket.auto_generated.open.count
  end

  private

  def current_quarter
    month   = Date.current.month
    quarter = ((month - 1) / 3) + 1
    "Q#{quarter} #{Date.current.year}"
  end
end

# frozen_string_literal: true

class ObjectivesQueryService
  # Current state distribution
  def self.distribution
    FosmTransition.state_distribution("Objective")
  end

  # Active objectives with progress below threshold
  def self.at_risk_candidates(threshold: 40)
    Objective.active.where("progress_pct < ?", threshold).map do |obj|
      {
        id:           obj.id,
        title:        obj.title,
        progress_pct: obj.progress_pct,
        quarter:      obj.quarter,
        owner:        obj.owner.name,
        ends_on:      obj.ends_on
      }
    end
  end

  # Completion rate for a quarter
  def self.completion_rate(quarter:)
    objectives = Objective.in_quarter(quarter)
    return nil if objectives.empty?
    completed = objectives.where(status: :completed).count
    (completed.to_f / objectives.count * 100).round(1)
  end

  # Summarize for bot
  def self.summary_for_bot
    dist = distribution
    {
      draft:            dist["draft"].to_i,
      active:           dist["active"].to_i,
      at_risk:          dist["at_risk"].to_i,
      completed:        dist["completed"].to_i,
      abandoned:        dist["abandoned"].to_i,
      at_risk_details:  at_risk_candidates
    }
  end
end

# frozen_string_literal: true

class ObjectivesQueryTool
  DEFINITION = {
    name:        "query_objectives",
    description: "Query OKR objectives: counts by state, at-risk details, completion rates, " \
                 "quarter summaries. Use for: 'how many OKRs are at risk', " \
                 "'what's our completion rate', 'which objectives need attention'.",
    parameters:  {
      type:       "object",
      properties: {
        action: {
          type:        "string",
          enum:        %w[summary distribution at_risk_candidates completion_rate],
          description: "The query action to run"
        },
        quarter: {
          type:        "string",
          description: "Quarter string like 'Q1 2026' — used for completion_rate action"
        },
        threshold: {
          type:        "integer",
          description: "Progress percentage threshold for at_risk_candidates (default 40)"
        }
      },
      required: ["action"]
    }
  }.freeze

  def self.call(action:, quarter: nil, threshold: 40, **)
    case action
    when "summary"
      ObjectivesQueryService.summary_for_bot.to_json
    when "distribution"
      ObjectivesQueryService.distribution.to_json
    when "at_risk_candidates"
      ObjectivesQueryService.at_risk_candidates(threshold: threshold.to_i).to_json
    when "completion_rate"
      rate = ObjectivesQueryService.completion_rate(quarter: quarter)
      { quarter: quarter, completion_rate_pct: rate }.to_json
    else
      { error: "Unknown action: #{action}" }.to_json
    end
  end
end

# db/seeds.rb — add to module settings

ModuleSetting.find_or_create_by!(module_name: "objectives") do |m|
  m.display_name = "OKRs & Objectives"
  m.enabled      = true
  m.icon         = "target"
  m.description  = "Track strategic objectives and key results through their lifecycle."
end

ModuleSetting.find_or_create_by!(module_name: "pay_runs") do |m|
  m.display_name = "Payroll"
  m.enabled      = true
  m.icon         = "banknotes"
  m.description  = "Manage pay run approval workflow and generate pay slips."
end

ModuleSetting.find_or_create_by!(module_name: "feedback_tickets") do |m|
  m.display_name = "Feedback"
  m.enabled      = true
  m.icon         = "chat-bubble-left-right"
  m.description  = "Track feedback tickets from reported through resolved."
end