---
phase: 96-automation-payment-method
plan: 01
type: execute
wave: 1
depends_on: []
files_modified:
  - src/Modules/Automation/AutomationController.php
  - src/Modules/Automation/AutomationService.php
  - resources/views/automation/form.php
autonomous: false
delegation: off
---

<objective>
## Goal
Dodanie nowego warunku automatyzacji `payment_method` (metoda/rodzaj platnosci) z opcja "Platnosc przy odbiorze (COD)" oraz innymi metodami. Warunek sprawdza pole `external_payment_type_id` zamowienia.

## Purpose
Uzytkownik chce triggerowac reguly automatyzacji w zaleznosci od metody platnosci (np. COD vs przelew), co jest ortogonalne do statusu platnosci (oplacone/nieoplacone). Pozwala np. na: "Gdy metoda = Pobranie AND status = Nieoplacone -> wyslij email z przypomnieniem".

## Output
- Nowy typ warunku `payment_method` w automatyzacji
- Predefiniowane opcje: Platnosc przy odbiorze (COD), Przelew, Karta, Inna
- Ewaluacja warunku porownuje `external_payment_type_id` z wybranymi metodami (COD uzywa StringHelper::isCodPayment)
</objective>

<context>
## Project Context
@.paul/PROJECT.md
@.paul/ROADMAP.md
@.paul/STATE.md

## Source Files
@src/Modules/Automation/AutomationController.php (ALLOWED_CONDITION_TYPES, PAYMENT_STATUS_OPTIONS, parseConditions, renderForm)
@src/Modules/Automation/AutomationService.php (evaluateSingleCondition, evaluatePaymentStatusCondition)
@resources/views/automation/form.php (condition type select, checkbox-group pattern)
@src/Core/Support/StringHelper.php (isCodPayment — normalizacja COD)
</context>

<skills>
No specialized flows configured.
</skills>

<acceptance_criteria>

## AC-1: Warunek payment_method dostepny w formularzu
```gherkin
Given uzytkownik tworzy/edytuje regule automatyzacji
When wybierze typ warunku "Metoda platnosci"
Then zobaczy checkboxy: "Platnosc przy odbiorze (COD)", "Przelew", "Karta/online", "Inna"
```

## AC-2: Ewaluacja warunku COD
```gherkin
Given regula ma warunek payment_method = ["cod"]
When zdarzenie dotyczy zamowienia z external_payment_type_id rozpoznawanym jako COD (np. "CASH_ON_DELIVERY", "pobranie", "za pobraniem")
Then warunek jest spelniony (uzywa StringHelper::isCodPayment)
```

## AC-3: Ewaluacja warunku nie-COD
```gherkin
Given regula ma warunek payment_method = ["transfer"]
When zdarzenie dotyczy zamowienia z external_payment_type_id = "przelew" lub "wire_transfer" lub "bank_transfer"
Then warunek jest spelniony
And zamowienie COD NIE spelnia tego warunku
```

## AC-4: Zapis i odczyt warunku
```gherkin
Given uzytkownik zapisal regule z warunkiem payment_method
When edytuje te regule ponownie
Then checkboxy payment_method sa poprawnie zaznaczone (zachowanie stanu)
```

</acceptance_criteria>

<tasks>

<task type="auto">
  <name>Task 1: Backend — nowy warunek payment_method</name>
  <files>src/Modules/Automation/AutomationController.php, src/Modules/Automation/AutomationService.php</files>
  <action>
    **AutomationController.php:**
    1. Dodac 'payment_method' do ALLOWED_CONDITION_TYPES
    2. Dodac stala PAYMENT_METHOD_OPTIONS:
       ```php
       private const PAYMENT_METHOD_OPTIONS = [
           'cod' => 'Platnosc przy odbiorze (COD)',
           'transfer' => 'Przelew bankowy',
           'online' => 'Karta / platnosc online',
           'other' => 'Inna',
       ];
       ```
    3. W renderForm() przekazac 'paymentMethodOptions' => self::PAYMENT_METHOD_OPTIONS
    4. W parseConditions() dodac obsluge typu 'payment_method':
       - Odczytac `$cond['payment_method_keys']` jako tablica
       - Zapisac jako `['method_keys' => [...]]`
    5. W walidacji (validateConditionValue lub analogiczne) dodac obsluge 'payment_method':
       - Odczytac `$condition['payment_method_keys']`, filtrowac przez array_keys(PAYMENT_METHOD_OPTIONS)
       - Zwrocic `['method_keys' => [...]]` lub null jesli puste

    **AutomationService.php:**
    1. W evaluateSingleCondition() dodac case 'payment_method':
       ```php
       if ($type === 'payment_method') {
           return $this->evaluatePaymentMethodCondition($value, $order);
       }
       ```
    2. Nowa metoda evaluatePaymentMethodCondition(array $value, array $order): bool
       - Pobrac $methodKeys z $value['method_keys'] (tablica stringow)
       - Pobrac $paymentType z $order['external_payment_type_id']
       - Jesli $paymentType pusty — return false
       - Dla kazdego wybranego klucza:
         - 'cod': sprawdzic StringHelper::isCodPayment($paymentType)
         - 'transfer': sprawdzic czy $paymentType zawiera 'PRZELEW', 'TRANSFER', 'WIRE' (case-insensitive)
         - 'online': sprawdzic czy zawiera 'CARD', 'ONLINE', 'PAYU', 'PRZELEWY24', 'BLIK', 'TPAY'
         - 'other': true jesli zaden z powyzszych nie pasowal
       - Return true jesli JAKIKOLWIEK wybrany klucz pasuje (OR logic, jak payment_status)
  </action>
  <verify>
    Przegladnij kod — warunek 'payment_method' jest w ALLOWED_CONDITION_TYPES, evaluateSingleCondition ma nowy case, parseConditions obsluguje nowy typ
  </verify>
  <done>AC-2, AC-3, AC-4 (backend) — ewaluacja i zapis warunku payment_method dziala</done>
</task>

<task type="auto">
  <name>Task 2: Frontend — UI warunku payment_method w formularzu</name>
  <files>resources/views/automation/form.php</files>
  <action>
    1. W select typu warunku (linia ~83-89) dodac nowa opcje:
       ```php
       <option value="payment_method"<?= ((string) ($cond['condition_type'] ?? '')) === 'payment_method' ? ' selected' : '' ?>>Metoda platnosci</option>
       ```
       Umiescic PO "Status platnosci" a PRZED "Status zamowienia"

    2. W sekcji renderowania pol warunku (po bloku payment_status, linia ~115) dodac:
       ```php
       <?php elseif ($conditionType === 'payment_method'): ?>
         <div class="checkbox-group">
           <?php foreach ($paymentMethodOptions as $methodKey => $methodLabel): ?>
             <label class="checkbox-label">
               <input type="checkbox" name="conditions[<?= $idx ?>][payment_method_keys][]" value="<?= $e((string) $methodKey) ?>"<?= in_array((string) $methodKey, $selectedMethodKeys, true) ? ' checked' : '' ?>>
               <?= $e($methodLabel) ?>
             </label>
           <?php endforeach; ?>
         </div>
       ```

    3. W sekcji ustawiajacej $selectedStatusKeys (okolo linii ~75-80) dodac analogiczny blok dla payment_method:
       ```php
       $selectedMethodKeys = [];
       if (($cond['condition_type'] ?? '') === 'payment_method') {
           $condValue = is_array($cond['condition_value'] ?? null) ? $cond['condition_value'] : [];
           $selectedMethodKeys = is_array($condValue['method_keys'] ?? null) ? $condValue['method_keys'] : [];
       }
       ```

    4. W JS (onConditionTypeChange) upewnic sie ze payment_method jest obslugiwany jak inne typy z checkboxami — jesli JS generuje dynamicznie pola, dodac case 'payment_method' wzorowany na 'payment_status'
  </action>
  <verify>
    Otworz /settings/automation/create — w warunkach widoczna opcja "Metoda platnosci" z checkboxami po wybraniu
  </verify>
  <done>AC-1 i AC-4 (frontend) — warunek payment_method widoczny i funkcjonalny w UI</done>
</task>

<task type="checkpoint:human-verify" gate="blocking">
  <what-built>Nowy warunek automatyzacji "Metoda platnosci" z opcjami COD, Przelew, Karta, Inna</what-built>
  <how-to-verify>
    1. Otworz /settings/automation/create
    2. Dodaj warunek — sprawdz ze "Metoda platnosci" jest w liscie typow
    3. Wybierz "Metoda platnosci" — powinny pojawic sie 4 checkboxy
    4. Zaznacz "Platnosc przy odbiorze (COD)" + jakis event + akcje
    5. Zapisz regule
    6. Edytuj regule — checkbox COD powinien byc zaznaczony
    7. (opcjonalnie) Sprawdz ze regula triggeruje sie dla zamowienia COD
  </how-to-verify>
  <resume-signal>Type "approved" to continue, or describe issues to fix</resume-signal>
</task>

</tasks>

<boundaries>

## DO NOT CHANGE
- src/Core/Support/StringHelper.php (tylko czytac isCodPayment, nie modyfikowac)
- database/migrations/* (nie potrzeba nowej migracji — dane sa juz w external_payment_type_id)
- Istniejace warunki (payment_status, shipment_status, order_status, integration, days_in_status) — nie ruszac

## SCOPE LIMITS
- Nie dodawac nowego eventu — warunek payment_method dziala z KAZDYM istniejacym eventem (jak integration)
- Nie dodawac dynamicznego pobierania metod z bazy — predefiniowane opcje wystarczaja
- Nie zmieniac pola external_payment_type_id ani logiki importu

</boundaries>

<verification>
Before declaring plan complete:
- [ ] Warunek "Metoda platnosci" widoczny w formularzu automatyzacji
- [ ] 4 checkboxy (COD, Przelew, Karta/online, Inna) po wybraniu warunku
- [ ] Zapis i odczyt warunku dziala (edycja reguly zachowuje zaznaczenia)
- [ ] Ewaluacja COD rozpoznaje rożne warianty nazw (CASH_ON_DELIVERY, pobranie, za pobraniem)
- [ ] Ewaluacja "Inna" pasuje do metod niesklasyfikowanych
- [ ] Brak bledow PHP
</verification>

<success_criteria>
- Nowy typ warunku payment_method w ALLOWED_CONDITION_TYPES
- Ewaluacja w AutomationService oparta na StringHelper::isCodPayment + pattern matching
- UI z checkboxami identyczne wzorcem jak payment_status
- Regula z warunkiem payment_method poprawnie triggeruje sie dla zamowien COD
</success_criteria>

<output>
After completion, create `.paul/phases/96-automation-payment-method/96-01-SUMMARY.md`
</output>