package com.alexanderlogistics.ksef;

import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNotNull;

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.MethodOrderer;
import org.junit.jupiter.api.Order;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.TestMethodOrder;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.junit.jupiter.MockitoExtension;

@ExtendWith(MockitoExtension.class)
@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
public class KSeFAuthManagerTest {

    private KSeFAuthManager manager;

    @BeforeEach
    void setup() throws Exception {
        manager = new KSeFAuthManager();

        // Test config
        manager.setKsefToken(Params.TOKEN);
        manager.setKsefNip(Params.NIP);
        manager.setKsefEndpoint("https://ksef-test.mf.gov.pl/api/v2");
        manager.setDebug(true);

        // init() ausführen
        manager.init();
    }

    // ------------------------------------------------------------
    // 1) Challenge abholen
    // ------------------------------------------------------------
    @Test
    @Order(1)
    @DisplayName("GET /auth/challenge should return a challenge")
    void testChallenge() throws Exception {

        manager.getChallenge();

        assertNotNull(
                manager.getChallengeValue(),
                "Challenge darf nicht NULL sein");

        assertFalse(
                manager.getChallengeValue().isBlank(),
                "Challenge darf nicht leer sein");

        System.out.println("Challenge = " + manager.getChallengeValue());
    }

    // ------------------------------------------------------------
    // 2) Zertifikate holen (nur Public Keys)
    // ------------------------------------------------------------
    @Test
    @Order(2)
    @DisplayName("GET /security/public-key-certificates should return symmetric key certificate")
    void testPublicKeys() throws Exception {

        manager.getKsefPublicKeys();

        assertNotNull(manager.getSymmetricPublicKey(), "Symmetric RSA PublicKey muss vorhanden sein");
        assertNotNull(manager.getSymmetricCertBase64(), "Base64 Zertifikat muss vorhanden sein");

        System.out.println("Symmetric PublicKey OK");
    }

    // ------------------------------------------------------------
    // 3) KSeF Token Request
    // ------------------------------------------------------------
    @Test
    @Order(3)
    @DisplayName("POST /auth/ksef-token should return a token")
    void testKsefToken() throws Exception {

        // Challenge muss vorher geholt worden sein
        manager.getChallenge();

        // Token verschlüsseln
        manager.generateAuthToken();

        // Token-Call durchführen
        String authToken = manager.getAuthToken();
        assertNotNull(authToken, "auth token darf nicht NULL sein");

        String refNumber = manager.getRefNumber();
        assertNotNull(refNumber, "refNumber darf nicht NULL sein");

        System.out.println("Received KSeF Token OK");
    }
}