class CreateCandidates < ActiveRecord::Migration[8.1]
  def change
    create_table :candidates do |t|
      t.references :job_posting,    null: false, foreign_key: true
      t.references :created_by_user, null: false, foreign_key: { to_table: :users }
      t.references :assigned_hr_user, foreign_key: { to_table: :users }

      t.string  :full_name,          null: false
      t.string  :email,              null: false
      t.string  :phone
      t.string  :status,             default: "applied", null: false

      # Stage data
      t.text    :resume_text
      t.boolean :has_resume_attachment, default: false, null: false
      t.text    :screening_notes
      t.datetime :screened_at
      t.references :screened_by_user, foreign_key: { to_table: :users }

      t.text    :interview_notes
      t.datetime :interviewed_at
      t.references :interviewed_by_user, foreign_key: { to_table: :users }

      # Offer details
      t.decimal :offered_salary,     precision: 12, scale: 2
      t.string  :offered_currency,   default: "USD"
      t.date    :offer_expiry_date
      t.datetime :offer_made_at
      t.references :offer_made_by_user, foreign_key: { to_table: :users }

      # Hire / rejection
      t.date    :proposed_start_date
      t.datetime :hired_at
      t.datetime :rejected_at
      t.text    :rejection_reason

      t.timestamps
    end

    add_index :candidates, :status
    add_index :candidates, :email
    add_index :candidates, [:job_posting_id, :status]
  end
end

# frozen_string_literal: true

class Candidate < ApplicationRecord
  include Fosm::Lifecycle

  belongs_to :job_posting
  belongs_to :created_by_user, class_name: "User"
  belongs_to :assigned_hr_user, class_name: "User", optional: true
  belongs_to :screened_by_user, class_name: "User", optional: true
  belongs_to :interviewed_by_user, class_name: "User", optional: true
  belongs_to :offer_made_by_user, class_name: "User", optional: true

  has_one_attached :resume_file

  validates :full_name, presence: true
  validates :email, presence: true, format: { with: URI::MailTo::EMAIL_REGEXP }

  enum :status, {
    applied:      "applied",
    screening:    "screening",
    interviewing: "interviewing",
    offer:        "offer",
    hired:        "hired",
    rejected:     "rejected"
  }, default: :applied

  # ── FOSM Lifecycle ──────────────────────────────────────────────────────────
  # Based on Parolkar's FOSM paper: https://www.parolkar.com/fosm
  lifecycle do
    state :applied,      label: "Applied",      color: "slate",  initial: true
    state :screening,    label: "Screening",    color: "blue"
    state :interviewing, label: "Interviewing", color: "violet"
    state :offer,        label: "Offer Sent",   color: "amber"
    state :hired,        label: "Hired",        color: "green",  terminal: true
    state :rejected,     label: "Rejected",     color: "red",    terminal: true

    event :screen,      from: :applied,      to: :screening,    label: "Move to Screening"
    event :interview,   from: :screening,    to: :interviewing, label: "Schedule Interview"
    event :make_offer,  from: :interviewing, to: :offer,        label: "Make Offer"
    event :hire,        from: :offer,        to: :hired,        label: "Confirm Hire"
    event :reject,      from: [:applied, :screening, :interviewing, :offer], to: :rejected, label: "Reject"

    actors :human

    # Guards
    guard :has_resume, on: :screen,
          description: "Candidate must have a resume on file" do |candidate|
      candidate.has_resume?
    end

    guard :has_interview_notes, on: :make_offer,
          description: "Interview notes must be recorded before making an offer" do |candidate|
      candidate.interview_notes.present?
    end

    guard :has_offer_details, on: :hire,
          description: "Offer salary and start date must be set" do |candidate|
      candidate.offered_salary.present? && candidate.proposed_start_date.present?
    end

    # Side effects
    side_effect :send_offer_email, on: :make_offer,
                description: "Email offer notification to candidate" do |candidate, _transition|
      CandidateMailer.offer_notification(candidate).deliver_later
    end

    side_effect :notify_hr_on_hire, on: :hire,
                description: "Notify HR team of confirmed hire" do |candidate, _transition|
      candidate.assigned_hr_user&.notify!(
        title: "New hire confirmed",
        body: "#{candidate.full_name} has accepted the offer for #{candidate.job_posting.title}",
        record: candidate
      )
      HrSlackNotifier.hire_confirmed(candidate)
    end

    side_effect :record_hire_timestamp, on: :hire,
                description: "Stamp hired_at on confirmation" do |candidate, _transition|
      candidate.update_column(:hired_at, Time.current)
    end

    side_effect :record_rejection_timestamp, on: :reject,
                description: "Stamp rejected_at" do |candidate, _transition|
      candidate.update_column(:rejected_at, Time.current)
    end
  end
  # ── End Lifecycle ────────────────────────────────────────────────────────────

  scope :active_pipeline, -> { where.not(status: [:hired, :rejected]) }
  scope :for_job,         ->(job) { where(job_posting: job) }
  scope :hired_this_month, -> {
    where(status: :hired).where(hired_at: Time.current.beginning_of_month..)
  }

  # ── Public API ──────────────────────────────────────────────────────────────

  def has_resume?
    resume_text.present? || has_resume_attachment?
  end

  def pipeline_stage_number
    %w[applied screening interviewing offer hired rejected].index(status.to_s) + 1
  end

  def days_in_pipeline
    return nil unless applied? || screening? || interviewing? || offer?
    (Date.current - created_at.to_date).to_i
  end

  def screen!(actor:, notes: nil)
    self.screening_notes    = notes if notes
    self.screened_at        = Time.current
    self.screened_by_user   = actor
    save!
    transition!(:screen, actor: actor)
  end

  def schedule_interview!(actor:, notes: nil)
    self.interviewed_at       = Time.current
    self.interviewed_by_user  = actor
    self.interview_notes      = notes if notes
    save!
    transition!(:interview, actor: actor)
  end

  def make_offer!(actor:, salary:, currency: "USD", expiry_days: 7, start_date: nil)
    self.offered_salary      = salary
    self.offered_currency    = currency
    self.offer_expiry_date   = expiry_days.days.from_now.to_date
    self.offer_made_at       = Time.current
    self.offer_made_by_user  = actor
    self.proposed_start_date = start_date
    save!
    transition!(:make_offer, actor: actor)
  end

  def confirm_hire!(actor:)
    transition!(:hire, actor: actor)
  end

  def reject!(actor:, reason: nil)
    self.rejection_reason = reason
    save!
    transition!(:reject, actor: actor)
  end
end

# frozen_string_literal: true

class CandidatesController < ApplicationController
  before_action :authenticate_user!
  before_action :set_candidate, only: [:show, :edit, :update, :screen,
                                        :schedule_interview, :make_offer,
                                        :confirm_hire, :reject]

  def index
    @job_posting = JobPosting.find(params[:job_posting_id]) if params[:job_posting_id]
    @candidates = candidate_scope.order(created_at: :desc)
    @candidates = @candidates.where(status: params[:status]) if params[:status].present?
    @candidates = @candidates.for_job(@job_posting) if @job_posting
    @pipeline_counts = candidate_scope.group(:status).count
  end

  def show
    @transitions = @candidate.fosm_transitions.order(created_at: :desc)
  end

  def new
    @candidate = Candidate.new
    @job_postings = JobPosting.open
  end

  def create
    @candidate = Candidate.new(candidate_params)
    @candidate.created_by_user = current_user
    @candidate.assigned_hr_user = current_user if current_user.hr?

    if @candidate.save
      redirect_to @candidate, notice: "Candidate #{@candidate.full_name} added to pipeline."
    else
      @job_postings = JobPosting.open
      render :new, status: :unprocessable_entity
    end
  end

  def edit; end

  def update
    if @candidate.update(candidate_params)
      redirect_to @candidate, notice: "Candidate updated."
    else
      render :edit, status: :unprocessable_entity
    end
  end

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

  def screen
    @candidate.screen!(
      actor: current_user,
      notes: params.dig(:candidate, :screening_notes)
    )
    redirect_to @candidate, notice: "#{@candidate.full_name} moved to screening."
  rescue Fosm::TransitionError => e
    redirect_to @candidate, alert: "Cannot move to screening: #{e.message}"
  end

  def schedule_interview
    @candidate.schedule_interview!(
      actor: current_user,
      notes: params.dig(:candidate, :interview_notes)
    )
    redirect_to @candidate, notice: "Interview stage recorded."
  rescue Fosm::TransitionError => e
    redirect_to @candidate, alert: "Cannot schedule interview: #{e.message}"
  end

  def make_offer
    @candidate.make_offer!(
      actor: current_user,
      salary: params.dig(:candidate, :offered_salary),
      currency: params.dig(:candidate, :offered_currency) || "USD",
      start_date: params.dig(:candidate, :proposed_start_date)
    )
    redirect_to @candidate, notice: "Offer sent to #{@candidate.full_name}."
  rescue Fosm::TransitionError => e
    redirect_to @candidate, alert: "Cannot make offer: #{e.message}"
  end

  def confirm_hire
    @candidate.confirm_hire!(actor: current_user)
    redirect_to @candidate, notice: "#{@candidate.full_name} confirmed as hired. HR has been notified."
  rescue Fosm::TransitionError => e
    redirect_to @candidate, alert: "Cannot confirm hire: #{e.message}"
  end

  def reject
    @candidate.reject!(
      actor: current_user,
      reason: params.dig(:candidate, :rejection_reason)
    )
    redirect_to candidates_path, notice: "#{@candidate.full_name} has been rejected."
  rescue Fosm::TransitionError => e
    redirect_to @candidate, alert: "Cannot reject: #{e.message}"
  end

  private

  def set_candidate
    @candidate = Candidate.find(params[:id])
  end

  def candidate_scope
    Candidate.includes(:job_posting, :assigned_hr_user)
  end

  def candidate_params
    params.require(:candidate).permit(
      :job_posting_id, :full_name, :email, :phone,
      :resume_text, :resume_file,
      :offered_salary, :offered_currency, :proposed_start_date,
      :offer_expiry_date, :rejection_reason
    )
  end
end

resources :candidates do
  member do
    post :screen
    post :schedule_interview
    post :make_offer
    post :confirm_hire
    post :reject
  end
end

# Nested under job postings for pipeline view
resources :job_postings do
  resources :candidates, only: [:index, :new, :create]
end

# frozen_string_literal: true

class CandidateQueryService
  # Query candidates with optional filters
  def self.query(status: nil, job_posting_id: nil, days_in_pipeline_gt: nil, limit: 20)
    scope = Candidate.includes(:job_posting, :assigned_hr_user).order(created_at: :desc)
    scope = scope.where(status: status) if status.present?
    scope = scope.where(job_posting_id: job_posting_id) if job_posting_id.present?

    if days_in_pipeline_gt.present?
      cutoff = days_in_pipeline_gt.to_i.days.ago
      scope = scope.where("candidates.created_at <= ?", cutoff)
                   .where.not(status: [:hired, :rejected])
    end

    scope.limit(limit).map do |c|
      {
        id: c.id,
        full_name: c.full_name,
        email: c.email,
        status: c.status,
        job_title: c.job_posting.title,
        days_in_pipeline: c.days_in_pipeline,
        has_resume: c.has_resume?,
        assigned_hr: c.assigned_hr_user&.full_name,
        hired_at: c.hired_at&.iso8601,
        rejection_reason: c.rejection_reason
      }
    end
  end

  # Pipeline summary: count by stage
  def self.pipeline_summary(job_posting_id: nil)
    scope = Candidate.all
    scope = scope.where(job_posting_id: job_posting_id) if job_posting_id.present?
    scope.group(:status).count
  end

  # Time-to-hire metric for completed hires
  def self.time_to_hire_stats
    hires = Candidate.hired.where.not(hired_at: nil)
    return { count: 0 } if hires.none?

    days_list = hires.map { |c| (c.hired_at.to_date - c.created_at.to_date).to_i }
    {
      count: days_list.size,
      average_days: (days_list.sum.to_f / days_list.size).round(1),
      min_days: days_list.min,
      max_days: days_list.max
    }
  end
end

# frozen_string_literal: true

class CandidateQueryTool < ApplicationTool
  tool_name "query_candidates"
  description "Query the hiring pipeline. Filter by status, job posting, or time in pipeline. " \
              "Also returns pipeline summary counts and time-to-hire statistics."

  argument :action, type: :string, required: true,
           enum: ["list", "pipeline_summary", "time_to_hire"],
           description: "What to retrieve"

  argument :status, type: :string, required: false,
           enum: %w[applied screening interviewing offer hired rejected],
           description: "Filter by candidate status"

  argument :job_posting_id, type: :integer, required: false,
           description: "Filter by job posting ID"

  argument :days_in_pipeline_gt, type: :integer, required: false,
           description: "Return only candidates who have been in the pipeline longer than N days (active stages only)"

  argument :limit, type: :integer, required: false, default: 20,
           description: "Maximum number of candidates to return (max 50)"

  def call
    case arguments[:action]
    when "list"
      CandidateQueryService.query(
        status: arguments[:status],
        job_posting_id: arguments[:job_posting_id],
        days_in_pipeline_gt: arguments[:days_in_pipeline_gt],
        limit: [arguments[:limit] || 20, 50].min
      )
    when "pipeline_summary"
      CandidateQueryService.pipeline_summary(job_posting_id: arguments[:job_posting_id])
    when "time_to_hire"
      CandidateQueryService.time_to_hire_stats
    else
      { error: "Unknown action: #{arguments[:action]}" }
    end
  end
end

Fosm.configure do |config|
  config.register_module :candidates do |mod|
    mod.label        = "Hiring Pipeline"
    mod.icon         = "user-plus"
    mod.description  = "Track candidates from application through hire"
    mod.model        = Candidate
    mod.query_tool   = CandidateQueryTool
    mod.nav_group    = :people
    mod.color        = "violet"
  end
end

class CreateLeaveRequests < ActiveRecord::Migration[8.1]
  def change
    create_table :leave_requests do |t|
      t.references :user,           null: false, foreign_key: true
      t.references :approved_by,    foreign_key: { to_table: :users }
      t.references :rejected_by,    foreign_key: { to_table: :users }

      t.string  :leave_type,        null: false   # annual, sick, personal, unpaid
      t.date    :start_date,        null: false
      t.date    :end_date,          null: false
      t.integer :days_requested,    null: false
      t.string  :status,            default: "pending", null: false

      t.text    :reason
      t.text    :rejection_reason
      t.datetime :approved_at
      t.datetime :rejected_at
      t.datetime :cancelled_at

      t.timestamps
    end

    add_index :leave_requests, :status
    add_index :leave_requests, [:user_id, :status]
    add_index :leave_requests, [:user_id, :start_date]
  end
end

# frozen_string_literal: true

class LeaveRequest < ApplicationRecord
  include Fosm::Lifecycle

  belongs_to :user
  belongs_to :approved_by, class_name: "User", optional: true
  belongs_to :rejected_by, class_name: "User", optional: true

  validates :leave_type, presence: true,
            inclusion: { in: %w[annual sick personal unpaid] }
  validates :start_date, :end_date, presence: true
  validates :days_requested, presence: true,
            numericality: { greater_than: 0, less_than_or_equal_to: 30 }
  validate  :end_date_after_start_date

  enum :status, {
    pending:   "pending",
    approved:  "approved",
    rejected:  "rejected",
    cancelled: "cancelled"
  }, default: :pending

  # ── FOSM Lifecycle ──────────────────────────────────────────────────────────
  # Based on Parolkar's FOSM paper: https://www.parolkar.com/fosm
  lifecycle do
    state :pending,   label: "Pending",   color: "amber",  initial: true
    state :approved,  label: "Approved",  color: "green",  terminal: true
    state :rejected,  label: "Rejected",  color: "red",    terminal: true
    state :cancelled, label: "Cancelled", color: "slate",  terminal: true

    event :approve, from: :pending, to: :approved, label: "Approve"
    event :reject,  from: :pending, to: :rejected,  label: "Reject"
    event :cancel,  from: :pending, to: :cancelled, label: "Cancel"

    actors :human

    # Actor gate: can't approve your own leave request
    guard :not_self_approval, on: :approve,
          description: "Managers cannot approve their own leave requests" do |request, transition|
      transition.actor_id != request.user_id
    end

    # Data guard: must have available leave balance
    guard :has_leave_balance, on: :approve,
          description: "Employee must have sufficient leave balance" do |request|
      LeaveBalance.for(request.user, request.leave_type) >= request.days_requested
    end

    # Side effect: deduct from leave balance when approved
    side_effect :deduct_leave_balance, on: :approve,
                description: "Deduct approved days from leave balance" do |request, _transition|
      LeaveBalance.deduct!(request.user, request.leave_type, request.days_requested)
    end

    side_effect :stamp_approved_at, on: :approve do |request, transition|
      request.update_columns(
        approved_at: Time.current,
        approved_by_id: transition.actor_id
      )
    end

    side_effect :stamp_rejected_at, on: :reject do |request, transition|
      request.update_columns(
        rejected_at: Time.current,
        rejected_by_id: transition.actor_id
      )
    end

    side_effect :notify_employee, on: [:approve, :reject],
                description: "Notify the employee of the decision" do |request, transition|
      decision = transition.to_state == "approved" ? "approved" : "rejected"
      request.user.notify!(
        title: "Leave request #{decision}",
        body: "Your #{request.leave_type} leave request for #{request.start_date} " \
              "to #{request.end_date} has been #{decision}.",
        record: request
      )
    end
  end
  # ── End Lifecycle ────────────────────────────────────────────────────────────

  scope :pending_approval, -> { where(status: :pending) }
  scope :for_user,         ->(u) { where(user: u) }
  scope :overlapping,      ->(start_d, end_d) {
    where("start_date <= ? AND end_date >= ?", end_d, start_d)
  }

  def approve!(actor:)
    transition!(:approve, actor: actor)
  end

  def reject!(actor:, reason: nil)
    self.rejection_reason = reason
    save!
    transition!(:reject, actor: actor)
  end

  def cancel!(actor:)
    transition!(:cancel, actor: actor)
  end

  private

  def end_date_after_start_date
    return unless start_date && end_date
    errors.add(:end_date, "must be on or after start date") if end_date < start_date
  end
end

# frozen_string_literal: true

class LeaveRequestsController < ApplicationController
  before_action :authenticate_user!
  before_action :set_leave_request, only: [:show, :approve, :reject, :cancel]

  def index
    @leave_requests = LeaveRequest.includes(:user, :approved_by)
                                  .order(created_at: :desc)
    # Managers see team requests; employees see their own
    @leave_requests = if current_user.manager?
                        @leave_requests.pending_approval
                      else
                        @leave_requests.for_user(current_user)
                      end
  end

  def create
    @leave_request = LeaveRequest.new(leave_request_params)
    @leave_request.user = current_user

    if @leave_request.save
      redirect_to @leave_request, notice: "Leave request submitted."
    else
      render :new, status: :unprocessable_entity
    end
  end

  def approve
    @leave_request.approve!(actor: current_user)
    redirect_to leave_requests_path, notice: "Leave approved."
  rescue Fosm::TransitionError => e
    redirect_to @leave_request, alert: "Cannot approve: #{e.message}"
  end

  def reject
    @leave_request.reject!(
      actor: current_user,
      reason: params.dig(:leave_request, :rejection_reason)
    )
    redirect_to leave_requests_path, notice: "Leave rejected."
  rescue Fosm::TransitionError => e
    redirect_to @leave_request, alert: "Cannot reject: #{e.message}"
  end

  def cancel
    @leave_request.cancel!(actor: current_user)
    redirect_to leave_requests_path, notice: "Leave request cancelled."
  rescue Fosm::TransitionError => e
    redirect_to @leave_request, alert: "Cannot cancel: #{e.message}"
  end

  private

  def set_leave_request
    @leave_request = LeaveRequest.find(params[:id])
  end

  def leave_request_params
    params.require(:leave_request).permit(
      :leave_type, :start_date, :end_date, :days_requested, :reason
    )
  end
end

# config/routes.rb
resources :leave_requests do
  member do
    post :approve
    post :reject
    post :cancel
  end
end

# frozen_string_literal: true

class LeaveRequestQueryTool < ApplicationTool
  tool_name "query_leave_requests"
  description "Query leave requests. Filter by status, user, leave type, or date range. " \
              "Returns pending approvals, approved leaves, and leave balance summaries."

  argument :action, type: :string, required: true,
           enum: ["list", "pending_approvals", "balance_summary"],
           description: "What to retrieve"

  argument :status, type: :string, required: false,
           enum: %w[pending approved rejected cancelled]

  argument :user_id, type: :integer, required: false,
           description: "Filter by employee user ID"

  argument :leave_type, type: :string, required: false,
           enum: %w[annual sick personal unpaid]

  argument :start_date_from, type: :string, required: false,
           description: "ISO8601 date — return requests with start_date on or after this date"

  def call
    case arguments[:action]
    when "list"
      scope = LeaveRequest.includes(:user).order(created_at: :desc).limit(30)
      scope = scope.where(status: arguments[:status])    if arguments[:status]
      scope = scope.where(user_id: arguments[:user_id]) if arguments[:user_id]
      scope = scope.where(leave_type: arguments[:leave_type]) if arguments[:leave_type]
      if arguments[:start_date_from]
        scope = scope.where("start_date >= ?", Date.parse(arguments[:start_date_from]))
      end
      scope.map { |r| serialize_request(r) }
    when "pending_approvals"
      LeaveRequest.pending_approval.includes(:user).order(:start_date).map { |r| serialize_request(r) }
    when "balance_summary"
      user = User.find(arguments[:user_id]) if arguments[:user_id]
      LeaveBalance.summary_for(user || :all)
    end
  end

  private

  def serialize_request(r)
    {
      id: r.id,
      employee: r.user.full_name,
      leave_type: r.leave_type,
      start_date: r.start_date.iso8601,
      end_date: r.end_date.iso8601,
      days_requested: r.days_requested,
      status: r.status,
      reason: r.reason
    }
  end
end

class CreateTimeEntries < ActiveRecord::Migration[8.1]
  def change
    create_table :time_entries do |t|
      t.references :user,         null: false, foreign_key: true
      t.references :project,      null: false, foreign_key: true
      t.references :approved_by,  foreign_key: { to_table: :users }

      t.date    :entry_date,      null: false
      t.decimal :hours,           precision: 5, scale: 2, null: false
      t.string  :description,     null: false
      t.string  :status,          default: "logged", null: false

      t.text    :rejection_notes
      t.datetime :submitted_at
      t.datetime :approved_at

      t.timestamps
    end

    add_index :time_entries, :status
    add_index :time_entries, [:project_id, :status]
    add_index :time_entries, [:user_id, :entry_date]
    add_index :time_entries, [:project_id, :entry_date]
  end
end

# frozen_string_literal: true

class TimeEntry < ApplicationRecord
  include Fosm::Lifecycle

  belongs_to :user
  belongs_to :project
  belongs_to :approved_by, class_name: "User", optional: true

  validates :entry_date, presence: true
  validates :hours, presence: true,
            numericality: { greater_than: 0, less_than_or_equal_to: 24 }
  validates :description, presence: true, length: { maximum: 500 }

  enum :status, {
    logged:    "logged",
    submitted: "submitted",
    approved:  "approved",
    rejected:  "rejected"
  }, default: :logged

  # ── FOSM Lifecycle ──────────────────────────────────────────────────────────
  # Based on Parolkar's FOSM paper: https://www.parolkar.com/fosm
  lifecycle do
    state :logged,    label: "Logged",    color: "slate", initial: true
    state :submitted, label: "Submitted", color: "blue"
    state :approved,  label: "Approved",  color: "green", terminal: true
    state :rejected,  label: "Rejected",  color: "red",   terminal: true

    event :submit, from: :logged,    to: :submitted, label: "Submit for Approval"
    event :approve, from: :submitted, to: :approved,  label: "Approve"
    event :reject,  from: [:logged, :submitted], to: :rejected, label: "Reject"

    actors :human

    # Actor gate: can't approve own time entry
    guard :not_self_approval, on: :approve,
          description: "Project leads cannot approve their own time entries" do |entry, transition|
      transition.actor_id != entry.user_id
    end

    # Data guard: project must be active
    guard :has_valid_project, on: :submit,
          description: "Time can only be submitted against an active project" do |entry|
      entry.project.active?
    end

    # Side effect: update project hours on approval
    side_effect :update_project_hours, on: :approve,
                description: "Add approved hours to project total" do |entry, _transition|
      entry.project.increment!(:approved_hours, entry.hours)
    end

    side_effect :stamp_submitted_at, on: :submit do |entry, _transition|
      entry.update_column(:submitted_at, Time.current)
    end

    side_effect :stamp_approved_at, on: :approve do |entry, transition|
      entry.update_columns(
        approved_at: Time.current,
        approved_by_id: transition.actor_id
      )
    end
  end
  # ── End Lifecycle ────────────────────────────────────────────────────────────

  scope :for_project, ->(p)  { where(project: p) }
  scope :for_user,    ->(u)  { where(user: u) }
  scope :for_period,  ->(s, e) { where(entry_date: s..e) }
  scope :billable,    ->     { joins(:project).where(projects: { billable: true }) }

  def submit!(actor:)
    self.submitted_at = Time.current
    save!
    transition!(:submit, actor: actor)
  end

  def approve!(actor:)
    transition!(:approve, actor: actor)
  end

  def reject!(actor:, notes: nil)
    self.rejection_notes = notes
    save!
    transition!(:reject, actor: actor)
  end
end

# In TimeEntriesController
def submit
  @time_entry.submit!(actor: current_user)
  redirect_to @time_entry, notice: "Time entry submitted for approval."
rescue Fosm::TransitionError => e
  redirect_to @time_entry, alert: "Cannot submit: #{e.message}"
end

def approve
  @time_entry.approve!(actor: current_user)
  redirect_to project_time_entries_path(@time_entry.project),
              notice: "#{@time_entry.hours} hours approved."
rescue Fosm::TransitionError => e
  redirect_to @time_entry, alert: "Cannot approve: #{e.message}"
end

# frozen_string_literal: true

class TimeEntryQueryTool < ApplicationTool
  tool_name "query_time_entries"
  description "Query time entries. Filter by status, project, user, or date range. " \
              "Returns summaries of billable hours, pending approvals, and project time totals."

  argument :action, type: :string, required: true,
           enum: ["list", "pending_approvals", "project_summary", "user_summary"],
           description: "What to retrieve"

  argument :project_id,    type: :integer, required: false
  argument :user_id,       type: :integer, required: false
  argument :status,        type: :string,  required: false,
           enum: %w[logged submitted approved rejected]
  argument :date_from,     type: :string,  required: false, description: "ISO8601 date"
  argument :date_to,       type: :string,  required: false, description: "ISO8601 date"

  def call
    case arguments[:action]
    when "list"
      scope = build_scope
      scope.limit(50).map { |e| serialize(e) }
    when "pending_approvals"
      TimeEntry.submitted.includes(:user, :project).order(:submitted_at).map { |e| serialize(e) }
    when "project_summary"
      project = Project.find(arguments[:project_id])
      {
        project: project.name,
        total_approved_hours: project.approved_hours,
        budget_hours: project.budget_hours,
        utilization_pct: project.budget_hours > 0 ?
          (project.approved_hours / project.budget_hours * 100).round(1) : nil,
        pending_hours: TimeEntry.submitted.for_project(project).sum(:hours)
      }
    when "user_summary"
      user = User.find(arguments[:user_id])
      entries = TimeEntry.approved.for_user(user)
      entries = entries.for_period(Date.parse(arguments[:date_from]),
                                   Date.parse(arguments[:date_to])) if arguments[:date_from]
      {
        user: user.full_name,
        total_approved_hours: entries.sum(:hours),
        by_project: entries.group_by { |e| e.project.name }
                           .transform_values { |es| es.sum(&:hours) }
      }
    end
  end

  private

  def build_scope
    scope = TimeEntry.includes(:user, :project).order(entry_date: :desc)
    scope = scope.where(project_id: arguments[:project_id]) if arguments[:project_id]
    scope = scope.where(user_id: arguments[:user_id]) if arguments[:user_id]
    scope = scope.where(status: arguments[:status]) if arguments[:status]
    if arguments[:date_from]
      scope = scope.where("entry_date >= ?", Date.parse(arguments[:date_from]))
    end
    if arguments[:date_to]
      scope = scope.where("entry_date <= ?", Date.parse(arguments[:date_to]))
    end
    scope
  end

  def serialize(e)
    {
      id: e.id,
      user: e.user.full_name,
      project: e.project.name,
      entry_date: e.entry_date.iso8601,
      hours: e.hours,
      description: e.description,
      status: e.status,
      submitted_at: e.submitted_at&.iso8601,
      approved_at: e.approved_at&.iso8601
    }
  end
end