/**
 * Kultūraugu pārvaldības modulis
 * 
 * Apstrādā kultūraugu sugu un šķirņu pārvaldību darba devējiem (status=2).
 * Atļauj pievienot un dzēst kultūraugu sugas un šķirnes.
 * 
 * Funkcijas:
 * - Apskatīt visas kultūraugu sugas tabulā
 * - Pievienot jaunas kultūraugu sugas
 * - Dzēst kultūraugu sugas
 * - Apskatīt visas kultūraugu šķirnes tabulā
 * - Pievienot jaunas kultūraugu šķirnes ar sugu izvēli
 * - Dzēst kultūraugu šķirnes
 * - Atsevišķi veiksmes/kļūdu paziņojumi katrai cilnei
 * 
 * Lietotāju lomas:
 * - Status 1: Darbinieks (bez piekļuves)
 * - Status 2: Darba devējs (pilna piekļuve)
 * - Status 3: Administrators (bez piekļuves)
 */

const PlantsManager = (() => {
  let currentUser = null;      // Pašreizējais pieslēgtais lietotājs
  let species = [];            // Pieejamo kultūraugu sugu masīvs
  let breeds = [];             // Pieejamo kultūraugu šķirņu masīvs

  /**
   * Inicializē kultūraugu pārvaldības lapu
   * Ielādē galveni, pārbauda autentifikāciju un iestatīt notikumu klausītājus
   */
  const init = async () => {
    await HeaderManager.loadHeader('header-container');
    
    // Pārbauda autentifikāciju - pārsūta uz login, ja nav pieslēgies
    currentUser = JSON.parse(localStorage.getItem('user'));
    if (!currentUser) {
      window.location.href = 'login_lapa.html';
      return;
    }

    // Tikai darba devēji (status=2) var pārvaldīt kultūraugus
    if (currentUser.status !== 2) {
      showError('Jums nav atļaujas pārvaldīt kultūraugus.');
      setTimeout(() => window.location.href = 'index.html', 2000);
      return;
    }
    
    // Ielādē sugu un šķirņu datus
    await loadSpecies();
    await loadBreeds();
    
    // Iestatīt formu iesniegšanas apstrādātājus
    document.getElementById('addSpeciesForm').addEventListener('submit', handleAddSpecies);
    document.getElementById('addBreedForm').addEventListener('submit', handleAddBreed);
  };

  /**
   * Nosūta visas kultūraugu sugas no servera
   * Parāda tās sugu tabulā
   */
  const loadSpecies = async () => {
    try {
      const response = await fetch('http://localhost:3001/api/crop-species');
      if (!response.ok) throw new Error('Neizdevās ielādēt sugas');
      
      species = await response.json();
      displaySpeciesTable(species);
      populateSpeciesSelect();
      
    } catch (error) {
      console.error('Kļūda ielādējot sugas:', error);
      showSpeciesError('Neizdevās ielādēt sugas.');
    }
  };

  /**
   * Nosūta visas kultūraugu šķirnes no servera
   * Parāda tās šķirņu tabulā
   */
  const loadBreeds = async () => {
    try {
      const response = await fetch('http://localhost:3001/api/crop-breeds');
      if (!response.ok) throw new Error('Neizdevās ielādēt šķirnes');
      
      breeds = await response.json();
      displayBreedsTable(breeds);
      
    } catch (error) {
      console.error('Kļūda ielādējot šķirnes:', error);
      showBreedError('Neizdevās ielādēt šķirnes.');
    }
  };

  /**
   * Papildina sugu "dropdown" izvēlni šķirņu formā
   * Atļauj lietotājam izvēlēties, kurai sugai pieder šķirne
   */
  const populateSpeciesSelect = () => {
    const select = document.getElementById('breedSpecies');
    select.innerHTML = '<option value="">Izvēlieties sugu...</option>';
    species.forEach(sp => {
      const option = document.createElement('option');
      option.value = sp.id;
      option.textContent = sp.name;
      select.appendChild(option);
    });
  };

  /**
   * Parāda sugas tabulas formātā
   * Parāda sugas nosaukumu un dzēšanas pogu
   */
  const displaySpeciesTable = (speciesList) => {
    const tbody = document.getElementById('speciesTableBody');
    
    if (speciesList.length === 0) {
      tbody.innerHTML = '<tr><td colspan="2" class="text-center text-muted">Nav atrasto sugu</td></tr>';
      return;
    }

    tbody.innerHTML = speciesList.map(sp => `
      <tr>
        <td>${sp.name}</td>
        <td>
          <button class="btn btn-sm btn-danger" onclick="PlantsManager.deleteSpecies(${sp.id})">
            Dzēst
          </button>
        </td>
      </tr>
    `).join('');
  };

  /**
   * Parāda šķirnes tabulas formātā
   * Parāda šķirnes nosaukumu, mātes sugu un dzēšanas pogu
   */
  const displayBreedsTable = (breedsList) => {
    const tbody = document.getElementById('breedsTableBody');
    
    if (breedsList.length === 0) {
      tbody.innerHTML = '<tr><td colspan="3" class="text-center text-muted">Nav atrasto šķirņu</td></tr>';
      return;
    }

    tbody.innerHTML = breedsList.map(breed => {
      const speciesName = species.find(s => s.id === breed.species_id)?.name || 'Nezināma';
      return `
      <tr>
        <td>${breed.name}</td>
        <td>${speciesName}</td>
        <td>
          <button class="btn btn-sm btn-danger" onclick="PlantsManager.deleteBreed(${breed.id})">
            Dzēst
          </button>
        </td>
      </tr>
    `;
    }).join('');
  };

  /**
   * Apstrādā jaunas sugas pievienošanu
   * Pārbauda ievadi un nosūta POST pieprasījumu uz serveri
   */
  const handleAddSpecies = async (e) => {
    e.preventDefault();
    
    const name = document.getElementById('speciesName').value.trim();

    if (!name) {
      showSpeciesError('Sugas nosaukums ir obligāts.');
      return;
    }

    try {
      const response = await fetch('http://localhost:3001/api/crop-species', {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json'
        },
        body: JSON.stringify({ name })
      });

      if (!response.ok) {
        const errorData = await response.json();
        throw new Error(errorData.error || 'Neizdevās pievienot sugu');
      }

      await response.json();
      showSpeciesSuccess('Suga pievienota veiksmīgi!');
      document.getElementById('addSpeciesForm').reset();
      
      // Pārlādē sugas, lai parādītu jauno ierakstu
      await loadSpecies();

    } catch (error) {
      console.error('Kļūda pievienojot sugu:', error);
      showSpeciesError(error.message || 'Neizdevās pievienot sugu.');
    }
  };

  /**
   * Apstrādā jaunas šķirnes pievienošanu
   * Pārbauda ievadi un nosūta POST pieprasījumu uz serveri
   */
  const handleAddBreed = async (e) => {
    e.preventDefault();
    
    const name = document.getElementById('breedName').value.trim();
    const speciesId = parseInt(document.getElementById('breedSpecies').value);

    if (!name || !speciesId) {
      showBreedError('Visi lauki ir obligāti.');
      return;
    }

    try {
      const response = await fetch('http://localhost:3001/api/crop-breeds', {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json'
        },
        body: JSON.stringify({
          name,
          species_id: speciesId
        })
      });

      if (!response.ok) {
        const errorData = await response.json();
        throw new Error(errorData.error || 'Neizdevās pievienot šķirni');
      }

      await response.json();
      showBreedSuccess('Šķirne pievienota veiksmīgi!');
      document.getElementById('addBreedForm').reset();
      
      // Pārlādē šķirnes, lai parādītu jauno ierakstu
      await loadBreeds();

    } catch (error) {
      console.error('Kļūda pievienojot šķirni:', error);
      showBreedError(error.message || 'Neizdevās pievienot šķirni.');
    }
  };

  /**
   * Dzēš sugu pēc apstiprinājuma
   * Nosūta DELETE pieprasījumu uz serveri
   */
  const deleteSpecies = async (id) => {
    if (!confirm('Vai tiešām vēlaties dzēst šo sugu?')) {
      return;
    }

    try {
      const response = await fetch(`http://localhost:3001/api/crop-species/${id}`, {
        method: 'DELETE'
      });

      if (!response.ok) {
        const errorData = await response.json();
        throw new Error(errorData.error || 'Neizdevās dzēst sugu');
      }

      await response.json();
      showSpeciesSuccess('Suga dzēsta veiksmīgi!');
      await loadSpecies();

    } catch (error) {
      console.error('Kļūda dzēšot sugu:', error);
      showSpeciesError(error.message || 'Neizdevās dzēst sugu.');
    }
  };

  /**
   * Dzēš šķirni pēc apstiprinājuma
   * Nosūta DELETE pieprasījumu uz serveri
   */
  const deleteBreed = async (id) => {
    if (!confirm('Vai tiešām vēlaties dzēst šo šķirni?')) {
      return;
    }

    try {
      const response = await fetch(`http://localhost:3001/api/crop-breeds/${id}`, {
        method: 'DELETE'
      });

      if (!response.ok) {
        const errorData = await response.json();
        throw new Error(errorData.error || 'Neizdevās dzēst šķirni');
      }

      await response.json();
      showBreedSuccess('Šķirne dzēsta veiksmīgi!');
      await loadBreeds();

    } catch (error) {
      console.error('Kļūda dzēšot šķirni:', error);
      showBreedError(error.message || 'Neizdevās dzēst šķirni.');
    }
  };

  /**
   * Parāda veiksmes paziņojumu sugu operācijām
   * Automātiski pazūd pēc 3 sekundēm
   */
  const showSpeciesSuccess = (message) => {
    const successDiv = document.getElementById('speciesSuccessMessage');
    if (successDiv) {
      successDiv.textContent = '✅ ' + message;
      successDiv.style.display = 'block';
      const errorDiv = document.getElementById('speciesErrorMessage');
      if (errorDiv) errorDiv.style.display = 'none';
      setTimeout(() => {
        successDiv.style.display = 'none';
      }, 3000);
    }
  };

  /**
   * Parāda kļūdas paziņojumu sugu operācijām
   */
  const showSpeciesError = (message) => {
    const errorDiv = document.getElementById('speciesErrorMessage');
    if (errorDiv) {
      errorDiv.textContent = '❌ ' + message;
      errorDiv.style.display = 'block';
      const successDiv = document.getElementById('speciesSuccessMessage');
      if (successDiv) successDiv.style.display = 'none';
    }
  };

  /**
   * Parāda veiksmes paziņojumu šķirņu operācijām
   * Automātiski pazūd pēc 3 sekundēm
   */
  const showBreedSuccess = (message) => {
    const successDiv = document.getElementById('breedSuccessMessage');
    if (successDiv) {
      successDiv.textContent = '✅ ' + message;
      successDiv.style.display = 'block';
      const errorDiv = document.getElementById('breedErrorMessage');
      if (errorDiv) errorDiv.style.display = 'none';
      setTimeout(() => {
        successDiv.style.display = 'none';
      }, 3000);
    }
  };

  /**
   * Parāda kļūdas paziņojumu šķirņu operācijām
   */
  const showBreedError = (message) => {
    const errorDiv = document.getElementById('breedErrorMessage');
    if (errorDiv) {
      errorDiv.textContent = '❌ ' + message;
      errorDiv.style.display = 'block';
      const successDiv = document.getElementById('breedSuccessMessage');
      if (successDiv) successDiv.style.display = 'none';
    }
  };

  /**
   * Parāda vispārēju kļūdas paziņojumu
   */
  const showError = (message) => {
    alert('❌ ' + message);
  };

  // Publiskais API - izpauž metodes, kas jāizsauc no HTML
  return {
    init,
    deleteSpecies,
    deleteBreed
  };
})();

// Inicializē, kad "DOM" ir gatavs
document.addEventListener('DOMContentLoaded', PlantsManager.init);
