require "rails_helper"

RSpec.describe "Public regia", type: :request do
  let!(:user) { User.create!(email: "regia@test.it", name: "U", password: "password123", role: "coach") }
  let!(:club) { Club.create!(name: "C", sport: "volleyball", primary_color: "#e53935", secondary_color: "#ffffff") }
  let!(:team) { club.teams.create!(name: "T", sport: "volleyball") }
  let!(:match) { team.matches.create!(opponent_name: "Opp", sport: "volleyball") }
  let!(:session) { StreamSession.create!(match: match, user: user, platform: "matchlivetv", status: "live") }

  it "mostra la pagina regia con token valido" do
    token = Sessions::RegiaAccess.new(session).issue_token!
    get public_regia_path(token)
    expect(response).to have_http_status(:ok)
    expect(response.body).to include("Condividi diretta")
    expect(response.body).to include("Condividi link regia")
    expect(response.body).to include("/live/#{session.id}")
    expect(response.body).not_to include("Aruba")
  end

  it "aggiorna il punteggio via API" do
    token = Sessions::RegiaAccess.new(session).issue_token!
    session.create_score_state!(home_sets: 0, away_sets: 0, home_points: 0, away_points: 0, current_set: 1)
    patch public_regia_score_path(token), params: { cmd: "home_point" }
    expect(response).to have_http_status(:ok)
    expect(session.score_state.reload.home_points).to eq(1)
  end

  it "aggiorna il punteggio basket via API senza errore 500" do
    basket_team = club.teams.create!(name: "U13 Basket", sport_key: "basket")
    basket_match = basket_team.matches.create!(
      opponent_name: "Avversario",
      sport: "basket",
      scoring_rules: { "periods" => 4, "period_duration_secs" => 600, "overtime_duration_secs" => 300 }
    )
    basket_session = StreamSession.create!(match: basket_match, user: user, platform: "matchlivetv", status: "live")
    basket_session.create_score_state!(
      board_type: "basket",
      home_sets: 0,
      away_sets: 0,
      home_points: 0,
      away_points: 0,
      current_set: 1,
      data: {
        "period" => 1,
        "clock_secs" => 600,
        "clock_running" => false,
        "home_score" => 0,
        "away_score" => 0,
        "overtime" => false
      }
    )
    token = Sessions::RegiaAccess.new(basket_session).issue_token!

    patch public_regia_score_path(token), params: { cmd: "home_point" }, as: :json
    expect(response).to have_http_status(:ok)
    body = response.parsed_body
    expect(body.dig("score", "home_points")).to eq(1)
    expect(body["points_target"]).to eq(0)

    get public_regia_status_path(token)
    expect(response).to have_http_status(:ok)
    expect(response.parsed_body.dig("score", "board_type")).to eq("basket")
  end

  it "avanza il quarto basket via API" do
    basket_team = club.teams.create!(name: "U13 Basket", sport_key: "basket")
    basket_match = basket_team.matches.create!(opponent_name: "Avversario", sport: "basket")
    basket_session = StreamSession.create!(match: basket_match, user: user, platform: "matchlivetv", status: "live")
    basket_session.create_score_state!(
      board_type: "basket",
      home_sets: 0,
      away_sets: 0,
      home_points: 0,
      away_points: 0,
      current_set: 1,
      data: {
        "period" => 1,
        "clock_secs" => 600,
        "clock_running" => false,
        "home_score" => 0,
        "away_score" => 4,
        "overtime" => false
      }
    )
    token = Sessions::RegiaAccess.new(basket_session).issue_token!

    patch public_regia_score_path(token), params: { cmd: "advance_period" }, as: :json
    expect(response).to have_http_status(:ok)
    body = response.parsed_body
    expect(body.dig("score", "period")).to eq("Q2")
    expect(body.dig("score", "data", "period")).to eq(2)
    expect(basket_session.score_state.reload.data["period"]).to eq(2)
  end

  it "avanza il quarto basket anche con periodo Q1 corrotto in data" do
    basket_team = club.teams.create!(name: "U13 Basket", sport_key: "basket")
    basket_match = basket_team.matches.create!(opponent_name: "Avversario", sport: "basket")
    basket_session = StreamSession.create!(match: basket_match, user: user, platform: "matchlivetv", status: "live")
    basket_session.create_score_state!(
      board_type: "basket",
      data: {
        "period" => "Q1",
        "home_score" => 0,
        "away_score" => 4,
        "clock_secs" => 600,
        "clock_running" => false,
        "overtime" => false
      }
    )
    token = Sessions::RegiaAccess.new(basket_session).issue_token!

    patch public_regia_score_path(token), params: { cmd: "advance_period" }, as: :json
    expect(response).to have_http_status(:ok)
    expect(response.parsed_body.dig("score", "period")).to eq("Q2")
  end

  it "non mostra controlli cronometro sulla regia basket" do
    basket_team = club.teams.create!(name: "U13 Basket", sport_key: "basket")
    basket_match = basket_team.matches.create!(opponent_name: "Avversario", sport: "basket")
    basket_session = StreamSession.create!(match: basket_match, user: user, platform: "matchlivetv", status: "live")
    basket_session.create_score_state!(board_type: "basket", data: { "period" => 1, "home_score" => 0, "away_score" => 0 })
    token = Sessions::RegiaAccess.new(basket_session).issue_token!

    get public_regia_path(token)
    expect(response).to have_http_status(:ok)
    expect(response.body).to include("Prossimo quarto")
    expect(response.body).not_to include("cronometro")
    expect(response.body).not_to include("Cronometro:")
  end

  it "mette in pausa e riprende la diretta" do
    mtx = instance_double(
      Mediamtx::Client,
      set_always_available: true,
      set_path_recording: true,
      delete_path: true,
      list_paths: []
    )
    allow(Mediamtx::Client).to receive(:new).and_return(mtx)

    token = Sessions::RegiaAccess.new(session).issue_token!
    post public_regia_pause_path(token)
    expect(response).to have_http_status(:ok)
    expect(session.reload.status).to eq("paused")

    post public_regia_resume_path(token)
    expect(response).to have_http_status(:ok)
    expect(session.reload.status).to eq("connecting")
  end

  it "emette token valido anche oltre le 8 ore dalla partenza" do
    session.update!(started_at: 9.hours.ago)
    token = Sessions::RegiaAccess.new(session).issue_token!
    session.reload
    expect(session.regia_token_expires_at).to be > Time.current
    get public_regia_path(token)
    expect(response).to have_http_status(:ok)
  end
end