Event loop, callbacki i Promise

console.log('start');
const start = Date.now();
while (Date.now() - start < 300) {
  // pusta pętla przez 300 ms – NIC innego nie może się wykonać: ani kliknięcie, ani odświeżenie ekranu
}
console.log('po 300 ms blokady');

console.log('1 – synchronicznie');

setTimeout(() => console.log('5 – zadanie (setTimeout 0 ms)'), 0);

Promise.resolve().then(() => console.log('3 – mikrozadanie (then)'));

queueMicrotask(() => console.log('4 – mikrozadanie (queueMicrotask)'));

console.log('2 – synchronicznie, koniec skryptu');

// „serwer”: po 200 ms oddaje dane przez callback (konwencja: pierwszy argument to błąd lub null)
function pobierzUzytkownika(id, callback) {
  setTimeout(() => callback(null, { id, imie: 'Ola' }), 200);
}
function pobierzZamowienia(uzytkownikId, callback) {
  setTimeout(() => callback(null, [{ nr: 1, kwota: 120 }, { nr: 2, kwota: 80 }]), 200);
}
function pobierzFakture(nrZamowienia, callback) {
  setTimeout(() => callback(null, `FV/2026/${nrZamowienia}`), 200);
}

// trzy kroki w zależności: użytkownik → jego zamówienia → faktura do pierwszego
pobierzUzytkownika(7, (blad, uzytkownik) => {
  if (blad) return console.error(blad);
  pobierzZamowienia(uzytkownik.id, (blad, zamowienia) => {
    if (blad) return console.error(blad);
    pobierzFakture(zamowienia[0].nr, (blad, faktura) => {
      if (blad) return console.error(blad);
      console.log(`${uzytkownik.imie} – ${zamowienia.length} zamówienia – faktura ${faktura}`);
      // a gdyby był czwarty krok? piąty? kod ucieka w prawo…
    });
  });
});
console.log('To wypisze się PIERWSZE – callbacki czekają na timery');

// Funkcja, która ZWRACA obietnicę zamiast przyjmować callback.
// Konstruktor dostaje executor – funkcję z dwoma „przełącznikami”: resolve i reject.
function czekaj(ms) {
  return new Promise((resolve) => {
    setTimeout(() => resolve(`minęło ${ms} ms`), ms);
  });
}

function rzutKostka() {
  return new Promise((resolve, reject) => {
    const oczko = Math.floor(Math.random() * 6) + 1;
    setTimeout(() => {
      if (oczko === 6) reject(new Error('Szóstka – gracz traci kolejkę'));
      else resolve(oczko);
    }, 100);
  });
}

const obietnica = czekaj(300);
console.log(obietnica instanceof Promise); // true
console.log(String(obietnica)); // [object Promise] – stanu nie odczytasz wprost, tylko przez then

obietnica.then((wynik) => console.log('then:', wynik)); // then: minęło 300 ms

rzutKostka()
  .then((oczko) => console.log('wyrzucono', oczko))
  .catch((blad) => console.log('catch:', blad.message))
  .finally(() => console.log('finally: tura zakończona (zawsze)'));

function pobierzUzytkownika(id) {
  return new Promise((resolve) => setTimeout(() => resolve({ id, imie: 'Ola' }), 200));
}
function pobierzZamowienia(uzytkownikId) {
  return new Promise((resolve) => setTimeout(() => resolve([{ nr: 1, kwota: 120 }, { nr: 2, kwota: 80 }]), 200));
}
function pobierzFakture(nr) {
  return new Promise((resolve) => setTimeout(() => resolve(`FV/2026/${nr}`), 200));
}

// Ta sama logika co w piramidzie – ale płasko, z jedną obsługą błędów
pobierzUzytkownika(7)
  .then((uzytkownik) => {
    console.log('mam użytkownika', uzytkownik.imie);
    return pobierzZamowienia(uzytkownik.id); // zwracamy OBIETNICĘ – następny then na nią poczeka
  })
  .then((zamowienia) => {
    const suma = zamowienia.reduce((acc, z) => acc + z.kwota, 0);
    console.log('suma zamówień:', suma);
    return pobierzFakture(zamowienia[0].nr);
  })
  .then((faktura) => {
    console.log('faktura:', faktura);
    return faktura.length; // zwykła wartość
  })
  .then((dlugosc) => console.log('długość numeru:', dlugosc)) // 9
  .catch((blad) => console.error('Coś poszło nie tak:', blad.message))
  .finally(() => console.log('koniec łańcucha'));

function parsujKwote(tekst) {
  return new Promise((resolve, reject) => {
    const n = Number(tekst);
    Number.isNaN(n) ? reject(new TypeError(`„${tekst}” to nie liczba`)) : resolve(n);
  });
}

parsujKwote('abc')
  .then((n) => {
    console.log('to się NIE wykona', n);
    return n * 2;
  })
  .catch((blad) => {
    console.log('złapano:', blad.message); // złapano: „abc” to nie liczba
    return 0; // wartość zastępcza – łańcuch wraca na tory
  })
  .then((n) => console.log('dalej z wartością', n)); // dalej z wartością 0

// wyjątek rzucony w then = odrzucenie
Promise.resolve('{ zly json')
  .then((tekst) => JSON.parse(tekst)) // SyntaxError
  .then(() => console.log('pominięte'))
  .catch((e) => console.log('catch dostał:', e.name)); // catch dostał: SyntaxError

// kolejność: catch dla pierwszego błędu, a potem łańcuch idzie dalej
Promise.reject(new Error('pierwszy'))
  .catch((e) => console.log('1.', e.message))
  .then(() => { throw new Error('drugi'); })
  .catch((e) => console.log('2.', e.message))
  .finally(() => console.log('finally bez argumentu'));

// 1. setTimeout → obietnica
const czekaj = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

czekaj(200).then(() => console.log('po 200 ms'));

// 2. funkcja z callbackiem (blad, wynik) → obietnica
function pobierzStary(id, callback) {
  setTimeout(() => (id > 0 ? callback(null, { id }) : callback(new Error('zły id'))), 100);
}
function pobierz(id) {
  return new Promise((resolve, reject) => {
    pobierzStary(id, (blad, wynik) => (blad ? reject(blad) : resolve(wynik)));
  });
}
pobierz(5).then((w) => console.log('pobrano', w));
pobierz(-1).catch((e) => console.log('błąd:', e.message));

// 3. Promise.withResolvers() – gdy resolve/reject potrzebujesz POZA executorem (np. „czekaj na kliknięcie”)
const { promise, resolve } = Promise.withResolvers();
promise.then((v) => console.log('rozstrzygnięto z zewnątrz:', v));
setTimeout(() => resolve('klik!'), 300);

const czekaj = (ms, wartosc) => new Promise((resolve) => setTimeout(() => resolve(wartosc), ms));
const odrzuc = (ms, powod) => new Promise((_, reject) => setTimeout(() => reject(new Error(powod)), ms));

const start = Date.now();

// all: trzy „zapytania” równolegle – całość trwa tyle, co najdłuższe (300 ms), nie 600
Promise.all([czekaj(300, 'produkty'), czekaj(100, 'kategorie'), czekaj(200, 'koszyk')]).then((wyniki) => {
  console.log('all:', wyniki, `po ~${Math.round((Date.now() - start) / 100) * 100} ms`);
  // all: ["produkty","kategorie","koszyk"] po ~300 ms – kolejność jak na wejściu, nie wg czasu
});

// all z błędem: odrzuca od razu, wyniki pozostałych przepadają
Promise.all([czekaj(400, 'a'), odrzuc(100, 'serwer padł')]).catch((e) => console.log('all catch:', e.message));

// allSettled: raport z każdej
Promise.allSettled([czekaj(100, 'ok'), odrzuc(100, 'nie ok')]).then((r) =>
  console.log('allSettled:', r.map((x) => x.status)) // ["fulfilled","rejected"]
);

// race: kto pierwszy – klasyczny timeout
Promise.race([czekaj(500, 'dane'), odrzuc(200, 'przekroczono czas')]).catch((e) => console.log('race:', e.message));

// any: pierwsza UDANA, błędy po drodze nie przeszkadzają
Promise.any([odrzuc(50, 'serwer 1'), czekaj(150, 'serwer 2 odpowiedział')]).then((w) => console.log('any:', w));