CREATE OR REPLACE PACKAGE PACK_IMPORT_PARTENERI AS

  -- ====================================================================
  -- CONSTANTS
  -- ====================================================================

  -- ID utilizator sistem pentru toate operatiile
  C_ID_UTIL_SISTEM CONSTANT NUMBER := -3;

  -- Valori default pentru adrese incomplete
  C_JUD_DEFAULT           CONSTANT VARCHAR2(50) := 'BUCURESTI';
  N_ID_JUD_DEFAULT        CONSTANT NUMBER(10) := 10;
  C_LOCALITATE_DEFAULT    CONSTANT VARCHAR2(50) := 'BUCURESTI SECTORUL 1';
  N_ID_LOCALITATE_DEFAULT CONSTANT NUMBER(10) := 1797;
  C_SECTOR_DEFAULT        CONSTANT VARCHAR2(50) := 'SECTOR 1';
  C_TARA_DEFAULT          CONSTANT VARCHAR2(50) := 'ROMANIA';
  N_ID_TARA_DEFAULT       CONSTANT NUMBER(10) := 1;

  -- Lungimi maxime pentru validari
  C_MIN_COD_FISCAL  CONSTANT NUMBER := 3;
  C_CUI_PERS_FIZICA CONSTANT NUMBER := 13; -- CNP are 13 cifre

  -- Variabila package pentru ultima eroare (pentru orchestrator VFP)
  g_last_error VARCHAR2(4000);

  -- ====================================================================
  -- CUSTOM EXCEPTIONS
  -- ====================================================================

  partener_invalid_exception EXCEPTION;
  PRAGMA EXCEPTION_INIT(partener_invalid_exception, -20001);

  adresa_invalid_exception EXCEPTION;
  PRAGMA EXCEPTION_INIT(adresa_invalid_exception, -20002);

  integrare_pack_def_exception EXCEPTION;
  PRAGMA EXCEPTION_INIT(integrare_pack_def_exception, -20003);

  -- ====================================================================
  -- PUBLIC FUNCTIONS
  -- ====================================================================

  /**
  * Procedura principala pentru cautarea sau crearea unui partener
  * SCHIMBAT din FUNCTION in PROCEDURE pentru compatibilitate cu DML operations
  *
  * Algoritm:
  * 1. Cauta dupa cod_fiscal (daca > 3 caractere)
  * 2. Cauta dupa denumire exacta
  * 3. Creeaza partener nou cu pack_def.adauga_partener()
  * 4. Adauga adresa cu pack_def.adauga_adresa_partener2()
  *
  * @param p_cod_fiscal Cod fiscal/CUI/CNP partener
  * @param p_denumire Denumirea partenerului (companie sau nume complet)
  * @param p_adresa Adresa in format: "JUD:Bucuresti;BUCURESTI;Str.Victoriei;10"
  * @param p_telefon Numar de telefon
  * @param p_email Adresa de email
  * @param p_is_persoana_juridica 1=persoana juridica, 0=persoana fizica, NULL=auto-detect prin CNP
  * @param p_id_partener OUT ID_PART al partenerului gasit sau creat
  */
  PROCEDURE cauta_sau_creeaza_partener(p_cod_fiscal           IN VARCHAR2,
                                       p_denumire             IN VARCHAR2,
                                       p_registru             IN VARCHAR2,
                                       p_is_persoana_juridica IN NUMBER DEFAULT NULL,
                                       p_id_partener          OUT NUMBER);

  procedure cauta_sau_creeaza_adresa(p_id_part   IN NUMBER,
                                     p_adresa    IN VARCHAR2,
                                     p_phone     IN VARCHAR2,
                                     p_email     IN VARCHAR2,
                                     p_id_adresa OUT NUMBER);
  /**
  * Parseaza o adresa din format semicolon in componentele individuale
  *
  * Format input: "JUD:Bucuresti;BUCURESTI;Str.Victoriei;10"
  * sau: "BUCURESTI;Str.Victoriei;10"
  * sau: "Str.Victoriei;10"
  *
  * @param p_adresa_text Textul adresei de parseat
  * @param p_judet OUT Judetul extras (default: Bucuresti)
  * @param p_localitate OUT Localitatea extrasa (default: BUCURESTI)
  * @param p_strada OUT Strada si numarul
  * @param p_sector OUT Sectorul (default: Sectorul 1)
  */
  PROCEDURE parseaza_adresa_semicolon(p_adresa_text IN VARCHAR2,
                                      p_judet       OUT VARCHAR2,
                                      p_localitate  OUT VARCHAR2,
                                      p_strada      OUT VARCHAR2,
                                      p_numar       OUT VARCHAR2,
                                      p_sector      OUT VARCHAR2);

  -- ====================================================================
  -- UTILITY FUNCTIONS (PUBLIC pentru testare)
  -- ====================================================================

  /**
  * Cauta partener dupa cod fiscal
  * @param p_cod_fiscal Codul fiscal de cautat
  * @return ID_PART sau NULL daca nu gaseste
  */
  FUNCTION cauta_partener_dupa_cod_fiscal(p_cod_fiscal IN VARCHAR2)
    RETURN NUMBER;

  /**
  * Cauta partener dupa denumire exacta
  * @param p_denumire Denumirea de cautat
  * @return ID_PART sau NULL daca nu gaseste
  */
  FUNCTION cauta_partener_dupa_denumire(p_denumire IN VARCHAR2) RETURN NUMBER;

  /**
  * Verifica daca un cod fiscal apartine unei persoane fizice (CNP)
  * @param p_cod_fiscal Codul fiscal de verificat
  * @return 1 daca este persoana fizica, 0 daca este companie
  */
  FUNCTION este_persoana_fizica(p_cod_fiscal IN VARCHAR2) RETURN NUMBER;

  /**
  * Separa numele complet in nume si prenume pentru persoane fizice
  * @param p_denumire_completa Numele complet
  * @param p_nume OUT Numele de familie
  * @param p_prenume OUT Prenumele
  */
  PROCEDURE separa_nume_prenume(p_denumire_completa IN VARCHAR2,
                                p_nume              OUT VARCHAR2,
                                p_prenume           OUT VARCHAR2);

  -- ====================================================================
  -- ERROR MANAGEMENT FUNCTIONS (similar cu PACK_JSON)
  -- ====================================================================

  /**
  * Returneaza ultima eroare pentru orchestrator VFP
  */
  FUNCTION get_last_error RETURN VARCHAR2;

  /**
  * Reseteaza eroarea
  */
  PROCEDURE clear_error;

END PACK_IMPORT_PARTENERI;
/
CREATE OR REPLACE PACKAGE BODY PACK_IMPORT_PARTENERI AS

  -- ================================================================
  -- ERROR MANAGEMENT FUNCTIONS IMPLEMENTATION
  -- ================================================================
  FUNCTION get_last_error RETURN VARCHAR2 IS
  BEGIN
    RETURN g_last_error;
  END get_last_error;

  PROCEDURE clear_error IS
  BEGIN
    g_last_error := NULL;
  END clear_error;

  -- ====================================================================
  -- PRIVATE FUNCTIONS
  -- ====================================================================

  /**
  * Valideaza datele unui partener inainte de creare
  */
  FUNCTION valideaza_date_partener(p_cod_fiscal IN VARCHAR2,
                                   p_denumire   IN VARCHAR2) RETURN BOOLEAN IS
  BEGIN
    -- Verificari obligatorii
    IF p_denumire IS NULL THEN
      g_last_error := 'Denumirea partenerului nu poate fi goala';
      RETURN FALSE;
    END IF;
  
    -- Cod fiscal optional, dar daca exista trebuie sa aiba minim 3 caractere
    IF p_cod_fiscal IS NOT NULL AND LENGTH(TRIM(p_cod_fiscal)) > 0 THEN
      IF LENGTH(TRIM(p_cod_fiscal)) < C_MIN_COD_FISCAL THEN
        g_last_error := 'Codul fiscal trebuie sa aiba minim ' ||
                        C_MIN_COD_FISCAL || ' caractere';
        RETURN FALSE;
      END IF;
    END IF;
  
    RETURN TRUE;
  
  EXCEPTION
    WHEN OTHERS THEN
      g_last_error := 'ERROR in valideaza_date_partener: ' || SQLERRM;
      RETURN FALSE;
  END valideaza_date_partener;

  /**
  * Curata si standardizeaza textul pentru cautare
  */
  FUNCTION curata_text_cautare(p_text IN VARCHAR2) RETURN VARCHAR2 IS
  BEGIN
    IF p_text IS NULL THEN
      RETURN NULL;
    END IF;
  
    RETURN UPPER(TRIM(p_text));
  END curata_text_cautare;

  -- ====================================================================
  -- PUBLIC FUNCTIONS IMPLEMENTATION
  -- ====================================================================

  FUNCTION cauta_partener_dupa_cod_fiscal(p_cod_fiscal IN VARCHAR2)
    RETURN NUMBER IS
    v_id_part          NUMBER;
    v_cod_fiscal_curat VARCHAR2(50);
  BEGIN
    -- Validare input
    IF p_cod_fiscal IS NULL OR
       LENGTH(TRIM(p_cod_fiscal)) < C_MIN_COD_FISCAL THEN
      RETURN NULL;
    END IF;
  
    v_cod_fiscal_curat := curata_text_cautare(p_cod_fiscal);
  
    -- pINFO('Cautare partener dupa cod_fiscal: ' || v_cod_fiscal_curat, 'IMPORT_PARTENERI');
  
    -- Cautare in NOM_PARTENERI
    BEGIN
      SELECT id_part
        INTO v_id_part
        FROM nom_parteneri
       WHERE UPPER(TRIM(cod_fiscal)) = v_cod_fiscal_curat
         AND ROWNUM = 1; -- In caz de duplicate, luam primul
    
      -- pINFO('Gasit partener cu cod_fiscal ' || v_cod_fiscal_curat || ': ID_PART=' || v_id_part, 'IMPORT_PARTENERI');
      RETURN v_id_part;
    
    EXCEPTION
      WHEN NO_DATA_FOUND THEN
        -- pINFO('Nu s-a gasit partener cu cod_fiscal: ' || v_cod_fiscal_curat, 'IMPORT_PARTENERI');
        RETURN NULL;
      
      WHEN TOO_MANY_ROWS THEN
        -- Luam primul gasit
        SELECT id_part
          INTO v_id_part
          FROM (SELECT id_part
                  FROM nom_parteneri
                 WHERE UPPER(TRIM(cod_fiscal)) = v_cod_fiscal_curat
                 ORDER BY id_part)
         WHERE ROWNUM = 1;
      
        pINFO('WARNING: Multiple parteneri cu acelasi cod_fiscal ' ||
              v_cod_fiscal_curat || '. Selectat ID_PART=' || v_id_part,
              'IMPORT_PARTENERI');
        RETURN v_id_part;
    END;
  
  EXCEPTION
    WHEN OTHERS THEN
      pINFO('ERROR in cauta_partener_dupa_cod_fiscal: ' || SQLERRM,
            'IMPORT_PARTENERI');
      RAISE;
  END cauta_partener_dupa_cod_fiscal;

  FUNCTION cauta_partener_dupa_denumire(p_denumire IN VARCHAR2) RETURN NUMBER IS
    v_id_part         NUMBER;
    v_denumire_curata VARCHAR2(200);
  BEGIN
    -- Validare input
    IF p_denumire IS NULL THEN
      RETURN NULL;
    END IF;
  
    v_denumire_curata := curata_text_cautare(p_denumire);
  
    -- pINFO('Cautare partener dupa denumire: ' || v_denumire_curata, 'IMPORT_PARTENERI');
  
    -- Cautare in NOM_PARTENERI
    BEGIN
      SELECT id_part
        INTO v_id_part
        FROM nom_parteneri
       WHERE UPPER(TRIM(denumire)) = v_denumire_curata
         AND ROWNUM = 1; -- In caz de duplicate, luam primul
    
      -- pINFO('Gasit partener cu denumirea ' || v_denumire_curata || ': ID_PART=' || v_id_part, 'IMPORT_PARTENERI');
      RETURN v_id_part;
    
    EXCEPTION
      WHEN NO_DATA_FOUND THEN
        -- pINFO('Nu s-a gasit partener cu denumirea: ' || v_denumire_curata, 'IMPORT_PARTENERI');
        RETURN NULL;
      
      WHEN TOO_MANY_ROWS THEN
        -- Luam primul gasit
        SELECT id_part
          INTO v_id_part
          FROM (SELECT id_part
                  FROM nom_parteneri
                 WHERE UPPER(TRIM(denumire)) = v_denumire_curata
                 ORDER BY id_part)
         WHERE ROWNUM = 1;
      
        pINFO('WARNING: Multiple parteneri cu aceeasi denumire ' ||
              v_denumire_curata || '. Selectat ID_PART=' || v_id_part,
              'IMPORT_PARTENERI');
        RETURN v_id_part;
    END;
  
  EXCEPTION
    WHEN OTHERS THEN
      pINFO('ERROR in cauta_partener_dupa_denumire: ' || SQLERRM,
            'IMPORT_PARTENERI');
      RAISE;
  END cauta_partener_dupa_denumire;

  FUNCTION este_persoana_fizica(p_cod_fiscal IN VARCHAR2) RETURN NUMBER IS
    v_cod_curat VARCHAR2(50);
  BEGIN
    IF p_cod_fiscal IS NULL THEN
      RETURN 0;
    END IF;
  
    v_cod_curat := TRIM(p_cod_fiscal);
  
    -- CNP-ul are exact 13 cifre
    IF LENGTH(v_cod_curat) = C_CUI_PERS_FIZICA AND
       REGEXP_LIKE(v_cod_curat, '^[0-9]{13}$') THEN
      RETURN 1;
    END IF;
  
    RETURN 0;
  
  EXCEPTION
    WHEN OTHERS THEN
      -- pINFO('ERROR in este_persoana_fizica: ' || SQLERRM, 'IMPORT_PARTENERI');
      RETURN 0;
  END este_persoana_fizica;

  PROCEDURE separa_nume_prenume(p_denumire_completa IN VARCHAR2,
                                p_nume              OUT VARCHAR2,
                                p_prenume           OUT VARCHAR2) IS
    v_pozitie_spatiu  NUMBER;
    v_denumire_curata VARCHAR2(200);
  BEGIN
    IF p_denumire_completa IS NULL THEN
      p_nume    := NULL;
      p_prenume := NULL;
      RETURN;
    END IF;
  
    v_denumire_curata := TRIM(p_denumire_completa);
  
    -- Cauta primul spatiu
    v_pozitie_spatiu := INSTR(v_denumire_curata, ' ');
  
    IF v_pozitie_spatiu > 0 THEN
      -- Numele = prima parte
      p_nume := TRIM(SUBSTR(v_denumire_curata, 1, v_pozitie_spatiu - 1));
      -- Prenumele = restul
      p_prenume := TRIM(SUBSTR(v_denumire_curata, v_pozitie_spatiu + 1));
    ELSE
      -- Nu exista spatiu, totul este nume
      p_nume    := v_denumire_curata;
      p_prenume := NULL;
    END IF;
  
    -- Validare lungimi maxime (sa nu depaseasca limitele tabelei)
    IF LENGTH(p_nume) > 50 THEN
      p_nume := SUBSTR(p_nume, 1, 50);
    END IF;
  
    IF LENGTH(p_prenume) > 50 THEN
      p_prenume := SUBSTR(p_prenume, 1, 50);
    END IF;
  
  EXCEPTION
    WHEN OTHERS THEN
      -- pINFO('ERROR in separa_nume_prenume: ' || SQLERRM, 'IMPORT_PARTENERI');
      p_nume    := SUBSTR(p_denumire_completa, 1, 50); -- fallback
      p_prenume := NULL;
  END separa_nume_prenume;

  PROCEDURE parseaza_adresa_semicolon(p_adresa_text IN VARCHAR2,
                                      p_judet       OUT VARCHAR2,
                                      p_localitate  OUT VARCHAR2,
                                      p_strada      OUT VARCHAR2,
                                      p_numar       OUT VARCHAR2,
                                      p_sector      OUT VARCHAR2) IS
    v_adresa_curata VARCHAR2(500);
    v_componente    SYS.ODCIVARCHAR2LIST := SYS.ODCIVARCHAR2LIST();
    v_count         NUMBER;
    v_temp_judet    VARCHAR2(100);
    v_pozitie       NUMBER;
    v_strada        VARCHAR2(100);
  BEGIN
    -- p_adresa_text: JUD: JUDET;LOCALITATE;STRADA, NR
    -- Initializare cu valori default
    p_judet      := C_JUD_DEFAULT;
    p_localitate := C_LOCALITATE_DEFAULT;
    p_strada     := NULL;
    p_sector     := C_SECTOR_DEFAULT;
  
    -- Validare input
    IF p_adresa_text IS NULL THEN
      -- pINFO('Adresa goala, se folosesc valorile default', 'IMPORT_PARTENERI');
      RETURN;
    END IF;
  
    v_adresa_curata := TRIM(p_adresa_text);
  
    -- pINFO('Parsare adresa: ' || v_adresa_curata, 'IMPORT_PARTENERI');
  
    -- Split dupa semicolon
    SELECT TRIM(REGEXP_SUBSTR(v_adresa_curata, '[^;]+', 1, LEVEL))
      BULK COLLECT
      INTO v_componente
      FROM DUAL
    CONNECT BY REGEXP_SUBSTR(v_adresa_curata, '[^;]+', 1, LEVEL) IS NOT NULL;
  
    v_count := v_componente.COUNT;
  
    IF v_count = 0 THEN
      -- pINFO('Nu s-au gasit componente in adresa', 'IMPORT_PARTENERI');
      RETURN;
    END IF;
  
    -- Parsare in functie de numarul de componente
    IF v_count = 1 THEN
      -- Doar strada
      p_strada := SUBSTR(v_componente(1), 1, 100);
    
    ELSIF v_count = 2 THEN
      -- Localitate;Strada
      p_localitate := SUBSTR(v_componente(1), 1, 100);
      p_strada     := SUBSTR(v_componente(2), 1, 100);
    
    ELSIF v_count >= 3 THEN
      -- Verifica daca prima componenta contine "JUD:"
      v_temp_judet := v_componente(1);
    
      IF UPPER(v_temp_judet) LIKE 'JUD:%' THEN
        -- Format: JUD:Bucuresti;BUCURESTI;Strada,Numar
        p_judet      := SUBSTR(REPLACE(v_temp_judet, 'JUD:', ''), 1, 100);
        p_localitate := SUBSTR(v_componente(2), 1, 100);
        p_strada     := SUBSTR(v_componente(3), 1, 100);
        v_strada := p_strada;
        
        -- Combina strada si numarul
        v_pozitie := INSTR(v_strada, ',');
        IF v_pozitie > 0 THEN
          p_strada := TRIM(SUBSTR(v_strada, 1, v_pozitie - 1));
          p_numar  := TRIM(SUBSTR(v_strada, v_pozitie + 1));
        
          -- Elimina prefixele din numele strazii (STR., STRADA, BD., BDUL., etc.)
          /*            v_nume_strada := TRIM(REGEXP_REPLACE(v_nume_strada, 
          '^(STR\.|STRADA|BD\.|BDUL\.|CALEA|PIATA|PTA\.|AL\.|ALEEA|SOS\.|SOSEA|INTR\.|INTRAREA)\s*', 
          '', 1, 1, 'i'));  */
        
          -- Elimina prefixele din numarul strazii (NR., NUMARUL, etc.)
          p_numar := TRIM(REGEXP_REPLACE(p_numar,
                                         '^(NR\.|NUMARUL|NUMAR)\s*',
                                         '',
                                         1,
                                         1,
                                         'i'));
        END IF;
      
      ELSE
        -- Format: Localitate;Strada;Altceva
        p_localitate := SUBSTR(v_componente(1), 1, 100);
        p_strada     := SUBSTR(v_componente(2) || ' ' || v_componente(3),
                               1,
                               100);
      END IF;
    END IF;
  
    -- Curatare finala
    p_judet      := UPPER(TRIM(p_judet));
    p_localitate := UPPER(TRIM(p_localitate));
    p_strada     := UPPER(TRIM(p_strada));
    p_numar      := UPPER(TRIM(p_numar));
    p_sector     := UPPER(TRIM(p_sector));
  
    -- Fallback pentru campuri goale
    IF p_judet IS NULL THEN
      p_judet := C_JUD_DEFAULT;
    END IF;
  
    IF p_localitate IS NULL THEN
      p_localitate := C_LOCALITATE_DEFAULT;
    END IF;
  
    IF p_sector IS NULL THEN
      p_sector := C_SECTOR_DEFAULT;
    END IF;
  
    -- pINFO('Adresa parsata: JUD=' || p_judet || ', LOC=' || p_localitate ||
    --            ', STRADA=' || NVL(p_strada, 'NULL') || ', SECTOR=' || p_sector, 'IMPORT_PARTENERI');
  
  EXCEPTION
    WHEN OTHERS THEN
      g_last_error := 'ERROR in parseaza_adresa_semicolon: ' || SQLERRM;
      -- pINFO('ERROR in parseaza_adresa_semicolon: ' || SQLERRM, 'IMPORT_PARTENERI');
    
      -- Pastram valorile default in caz de eroare
      p_judet      := C_JUD_DEFAULT;
      p_localitate := C_LOCALITATE_DEFAULT;
      p_sector     := C_SECTOR_DEFAULT;
  END parseaza_adresa_semicolon;

  PROCEDURE cauta_sau_creeaza_partener(p_cod_fiscal           IN VARCHAR2,
                                       p_denumire             IN VARCHAR2,
                                       p_registru             IN VARCHAR2,
                                       p_is_persoana_juridica IN NUMBER DEFAULT NULL,
                                       p_id_partener          OUT NUMBER) IS
  
    v_id_part              NUMBER;
    v_este_persoana_fizica NUMBER;
    v_nume                 VARCHAR2(50);
    v_prenume              VARCHAR2(50);
  
    -- Date pentru pack_def
    v_cod_fiscal_curat VARCHAR2(50);
    v_denumire_curata  VARCHAR2(200);
  
  BEGIN
    -- Resetare eroare la inceputul procesarii
    clear_error;
  
    -- pINFO('=== INCEPUT cauta_sau_creeaza_partener ===', 'IMPORT_PARTENERI');
    -- pINFO('Input: cod_fiscal=' || NVL(p_cod_fiscal, 'NULL') ||
    --            ', denumire=' || NVL(p_denumire, 'NULL') ||
    --            ', adresa=' || NVL(p_adresa, 'NULL'), 'IMPORT_PARTENERI');
  
    -- Validare date input
    IF NOT valideaza_date_partener(p_cod_fiscal, p_denumire) THEN
      g_last_error  := 'Date partener invalide - validare esuata';
      p_id_partener := -1;
      RETURN;
    END IF;
  
    v_cod_fiscal_curat := TRIM(p_cod_fiscal);
    v_denumire_curata  := TRIM(p_denumire);
  
    -- STEP 1: Cautare dupa cod fiscal (prioritate 1)
    IF v_cod_fiscal_curat IS NOT NULL AND
       LENGTH(v_cod_fiscal_curat) >= C_MIN_COD_FISCAL THEN
      v_id_part := cauta_partener_dupa_cod_fiscal(v_cod_fiscal_curat);
    
      IF v_id_part IS NOT NULL THEN
        -- pINFO('Partener gasit dupa cod_fiscal. ID_PART=' || v_id_part, 'IMPORT_PARTENERI');
        -- pINFO('=== SFARSIT cauta_sau_creeaza_partener ===', 'IMPORT_PARTENERI');
        p_id_partener := v_id_part;
        RETURN;
      END IF;
    END IF;
  
    -- STEP 2: Cautare dupa denumire exacta (prioritate 2)
    v_id_part := cauta_partener_dupa_denumire(v_denumire_curata);
  
    IF v_id_part IS NOT NULL THEN
      -- pINFO('Partener gasit dupa denumire. ID_PART=' || v_id_part, 'IMPORT_PARTENERI');
      -- pINFO('=== SFARSIT cauta_sau_creeaza_partener ===', 'IMPORT_PARTENERI');
      p_id_partener := v_id_part;
      RETURN;
    END IF;
  
    -- STEP 3: Creare partener nou
    -- pINFO('Nu s-a gasit partener existent. Se creeaza unul nou...', 'IMPORT_PARTENERI');
  
    -- Verifica tipul partenerului
    -- Prioritate: parametru explicit > detectie prin CNP
    IF p_is_persoana_juridica IS NOT NULL THEN
      -- Foloseste informatia explicita din GoMag orders
      v_este_persoana_fizica := CASE
                                  WHEN p_is_persoana_juridica = 1 THEN
                                   0
                                  ELSE
                                   1
                                END;
    ELSE
      -- Auto-detect prin CNP (comportament original)
      v_este_persoana_fizica := este_persoana_fizica(v_cod_fiscal_curat);
    END IF;
  
    IF v_este_persoana_fizica = 1 THEN
      -- pINFO('Detectata persoana fizica (CUI 13 cifre)', 'IMPORT_PARTENERI');
      separa_nume_prenume(v_denumire_curata, v_nume, v_prenume);
      -- pINFO('Nume separat: NUME=' || NVL(v_nume, 'NULL') || ', PRENUME=' || NVL(v_prenume, 'NULL'), 'IMPORT_PARTENERI');
    END IF;
  
    -- Creare partener prin pack_def
    BEGIN
      IF v_este_persoana_fizica = 1 THEN
        -- Pentru persoane fizice
        pack_def.adauga_partener(tcDenumire              => v_nume, -- nume de familie pentru persoane fizice
                                 tcNume                  => v_nume,
                                 tcPrenume               => v_prenume,
                                 tcCod_fiscal            => v_cod_fiscal_curat,
                                 tcReg_comert            => p_registru,
                                 tnId_loc                => NULL,
                                 tnId_categorie_entitate => NULL,
                                 tcPrefix                => '',
                                 tcSufix                 => '',
                                 tnTip_persoana          => 2, -- persoana fizica
                                 tcBanca                 => '', -- nu avem info bancara
                                 tcCont_banca            => '', -- nu avem info bancara
                                 tnInactiv               => 0,
                                 tcMotiv_inactiv         => '',
                                 tnId_util               => C_ID_UTIL_SISTEM,
                                 tcSir_id_tipPart        => '16;17',
                                 tcSir_id_part_del       => '',
                                 tnId_Part               => v_id_part);
      ELSE
        -- Pentru companii
        pack_def.adauga_partener(tcDenumire              => v_denumire_curata,
                                 tcNume                  => v_denumire_curata,
                                 tcPrenume               => '',
                                 tcCod_fiscal            => v_cod_fiscal_curat,
                                 tcReg_comert            => p_registru,
                                 tnId_loc                => NULL,
                                 tnId_categorie_entitate => NULL,
                                 tcPrefix                => '',
                                 tcSufix                 => '',
                                 tnTip_persoana          => 1, -- persoana juridica
                                 tcBanca                 => '', -- nu avem info bancara
                                 tcCont_banca            => '', -- nu avem info bancara
                                 tnInactiv               => 0,
                                 tcMotiv_inactiv         => '',
                                 tnId_util               => C_ID_UTIL_SISTEM,
                                 tcSir_id_tipPart        => '16;17',
                                 tcSir_id_part_del       => '',
                                 tnId_Part               => v_id_part);
      END IF;
    
      IF v_id_part IS NULL OR v_id_part <= 0 THEN
        g_last_error  := 'pack_def.adauga_partener a returnat ID invalid';
        p_id_partener := -1;
        RETURN;
      END IF;
    
      -- pINFO('Partener creat cu succes. ID_PART=' || v_id_part, 'IMPORT_PARTENERI');
    
    EXCEPTION
      WHEN OTHERS THEN
        g_last_error  := 'ERROR la crearea partenerului prin pack_def: ' ||
                         SQLERRM;
        p_id_partener := -1;
        RETURN;
    END;
  
    -- pINFO('Partener creat complet. ID_PART=' || v_id_part, 'IMPORT_PARTENERI');
    -- pINFO('=== SFARSIT cauta_sau_creeaza_partener ===', 'IMPORT_PARTENERI');
  
    p_id_partener := v_id_part;
  
  EXCEPTION
    WHEN OTHERS THEN
      g_last_error  := 'ERROR NEASTEPTAT in cauta_sau_creeaza_partener: ' ||
                       SQLERRM;
      p_id_partener := -1;
    
  END cauta_sau_creeaza_partener;

  procedure cauta_sau_creeaza_adresa(p_id_part   IN NUMBER,
                                     p_adresa    IN VARCHAR2,
                                     p_phone     IN VARCHAR2,
                                     p_email     IN VARCHAR2,
                                     p_id_adresa OUT NUMBER) is
    v_judet         VARCHAR2(200);
    v_id_judet      NUMBER(10);
    v_localitate    VARCHAR2(200);
    v_id_localitate NUMBER(10);
    v_strada        VARCHAR2(1000);
    v_numar         VARCHAR2(1000);
    v_sector        VARCHAR2(100);
    v_id_tara       NUMBER(10);
    v_principala    NUMBER(1);
  begin
    -- Resetare eroare la inceputul procesarii
    clear_error;
  
    IF p_id_part is null OR p_adresa IS NULL THEN
      GOTO sfarsit;
    END IF;
    -- pINFO('Se adauga adresa pentru partenerul nou creat...', 'IMPORT_PARTENERI');
  
    -- Verific daca exista o adresa principala
    SELECT DECODE(nr, 0, 1, 0)
      INTO v_principala
      FROM (SELECT count(id_adresa) nr
              from vadrese_parteneri
             where id_part = p_id_part
               and principala = 1);
  
    -- Parseaza adresa
    parseaza_adresa_semicolon(p_adresa,
                              v_judet,
                              v_localitate,
                              v_strada,
                              v_numar,
                              v_sector);
  
    -- caut prima adresa dupa judet si localitate, ordonate dupa principala = 1
    begin
      select max(id_adresa) over(order by principala desc)
        into p_id_adresa
        from vadrese_parteneri
       where id_part = p_id_part
         and judet = v_judet
         and localitate = v_localitate;
    exception
      WHEN NO_DATA_FOUND THEN
        p_id_adresa := null;
    end;
  
    -- caut prima adresa dupa judet, ordonate dupa principala = 1
    if p_id_adresa is null then
      begin
        select max(id_adresa) over(order by principala desc)
          into p_id_adresa
          from vadrese_parteneri
         where id_part = p_id_part
           and judet = v_judet;
      exception
        WHEN NO_DATA_FOUND THEN
          p_id_adresa := null;
      end;
    end if;
  
    -- Adaug o adresa
    if p_id_adresa is null then
      -- caut judetul
      begin
        select id_judet
          into v_id_judet
          from syn_nom_judete
         where judet = v_judet
           and sters = 0;
      exception
        when NO_DATA_FOUND then
          v_id_judet := N_ID_JUD_DEFAULT;
      end;
    
      -- caut localitatea
      begin
        select id_loc, id_judet, id_tara
          into v_id_localitate, v_id_judet, v_id_tara
          from (select id_loc, id_judet, id_tara, rownum rn
                  from syn_nom_localitati l
                 where id_judet = v_id_judet
                   and localitate = v_localitate
                   and inactiv = 0
                   and sters = 0
                 order by localitate)
         where rn = 1;
      exception
        when NO_DATA_FOUND then
          begin
            select id_loc, id_judet, id_tara
              into v_id_localitate, v_id_judet, v_id_tara
              from (select id_loc, id_judet, id_tara, rownum rn
                      from syn_nom_localitati l
                     where id_judet = v_id_judet
                       and inactiv = 0
                       and sters = 0
                     order by localitate)
             where rn = 1;
          exception
            when NO_DATA_FOUND then
              v_id_localitate := N_ID_LOCALITATE_DEFAULT;
              v_id_judet      := N_ID_JUD_DEFAULT;
              v_id_tara       := N_ID_TARA_DEFAULT;
          end;
      end;
    
      BEGIN
        pack_def.adauga_adresa_partener2(tnId_part         => p_id_part,
                                         tcDenumire_adresa => NULL,
                                         tnDA_apare        => 0,
                                         tcStrada          => v_strada,
                                         tcNumar           => v_numar,
                                         tcBloc            => NULL,
                                         tcScara           => NULL,
                                         tcApart           => NULL,
                                         tnEtaj            => NULL,
                                         tnId_loc          => v_id_localitate,
                                         tcLocalitate      => v_localitate,
                                         tnId_judet        => v_id_judet,
                                         tnCodpostal       => NULL,
                                         tnId_tara         => v_id_tara,
                                         tcTelefon1        => p_phone,
                                         tcTelefon2        => NULL,
                                         tcFax             => NULL,
                                         tcEmail           => p_email,
                                         tcWeb             => NULL,
                                         tnPrincipala      => to_char(v_principala),
                                         tnInactiv         => 0,
                                         tnId_util         => C_ID_UTIL_SISTEM,
                                         tnIdAdresa        => p_id_adresa);
      
        IF p_id_adresa IS NOT NULL AND p_id_adresa > 0 THEN
          -- pINFO('Adresa adaugata cu succes. ID_ADRESA=' || p_id_adresa, 'IMPORT_PARTENERI');
          NULL;
        ELSE
          g_last_error := 'WARNING: pack_def.adauga_adresa_partener2 a returnat ID invalid: ' ||
                          NVL(TO_CHAR(p_id_adresa), 'NULL');
          -- pINFO('WARNING: pack_def.adauga_adresa_partener2 a returnat ID invalid: ' || NVL(TO_CHAR(p_id_adresa), 'NULL'), 'IMPORT_PARTENERI');
        END IF;
      
      EXCEPTION
        WHEN OTHERS THEN
          g_last_error := 'ERROR la adaugarea adresei prin pack_def: ' ||
                          SQLERRM;
          -- pINFO('ERROR la adaugarea adresei prin pack_def: ' || SQLERRM, 'IMPORT_PARTENERI');
        -- Nu raisam exceptia pentru adresa, partenerii pot exista fara adresa
        -- pINFO('Partenerul a fost creat, dar adresa nu a putut fi adaugata', 'IMPORT_PARTENERI');
      END;
    END IF;
  
    <<sfarsit>>
    null;
  end;

END PACK_IMPORT_PARTENERI;
/