const promise = new Promise<string>((resolve, reject) => {
  // Executor-функція виконується НЕГАЙНО (синхронно)
  const success = Math.random() > 0.5;
  
  setTimeout(() => {
    if (success) {
      resolve('Операція успішна'); // Переводить проміс у стан fulfilled
    } else {
      reject(new Error('Операція провалилася')); // Переводить проміс у стан rejected
    }
  }, 1000);
});

console.log('Проміс створено:', promise); // Promise { <pending> }

// Реєстрація обробників
promise
  .then((result) => {
    console.log('Успіх:', result); // Виконується, якщо resolve()
  })
  .catch((error) => {
    console.error('Помилка:', error.message); // Виконується, якщо reject()
  });

import { readFile, writeFile } from 'node:fs/promises';

readFile('./input.json', 'utf-8')
  .then((content) => {
    console.log('Файл прочитано');
    return JSON.parse(content); // Повертаємо синхронне значення
  })
  .then((data) => {
    console.log('JSON розпарсено:', data);
    data.processed = true;
    data.timestamp = new Date().toISOString();
    return data; // Передаємо дані далі по ланцюжку
  })
  .then((modifiedData) => {
    const output = JSON.stringify(modifiedData, null, 2);
    return writeFile('./output.json', output, 'utf-8'); // Повертаємо проміс
  })
  .then(() => {
    console.log('Файл записано успішно');
  })
  .catch((error) => {
    console.error('Сталася помилка на будь-якому етапі:', error);
  })
  .finally(() => {
    console.log('Операція завершена (успішно або з помилкою)');
  });

function fetchUserData(userId: number): Promise<any> {
  return new Promise((resolve) => {
    setTimeout(() => {
      resolve({ id: userId, name: 'Олександр', email: 'alex@example.com' });
    }, 500);
  });
}

function fetchUserPosts(userId: number): Promise<any[]> {
  return new Promise((resolve) => {
    setTimeout(() => {
      resolve([
        { id: 1, title: 'Перший пост', userId },
        { id: 2, title: 'Другий пост', userId },
      ]);
    }, 300);
  });
}

fetchUserData(42)
  .then((user) => {
    console.log('Користувача знайдено:', user.name);
    // Повертаємо новий проміс — ланцюжок чекатиме його виконання
    return fetchUserPosts(user.id);
  })
  .then((posts) => {
    console.log('Пости користувача:', posts.length);
    console.log('Заголовки:', posts.map(p => p.title));
  })
  .catch((error) => {
    console.error('Помилка:', error);
  });

import { readFile } from 'node:fs/promises';

readFile('./config.json', 'utf-8')
  .then((content) => {
    return JSON.parse(content); // Може викинути SyntaxError
  })
  .then((config) => {
    if (!config.apiKey) {
      throw new Error('API ключ відсутній у конфігурації');
    }
    return config;
  })
  .then((config) => {
    console.log('Конфігурація валідна:', config);
  })
  .catch((error) => {
    // Цей обробник спрацює для БУДЬ-ЯКОЇ помилки у ланцюжку:
    // - Файл не знайдено (ENOENT)
    // - JSON невалідний (SyntaxError)
    // - API ключ відсутній (Error)
    console.error('Помилка завантаження конфігурації:', error.message);
  });

readFile('./primary-config.json', 'utf-8')
  .catch((error) => {
    console.warn('Основна конфігурація недоступна, використовуємо резервну');
    // Відновлюємо ланцюжок, повертаючи резервне значення
    return '{"apiKey": "default-key", "timeout": 5000}';
  })
  .then((content) => JSON.parse(content))
  .then((config) => {
    console.log('Завантажено конфігурацію:', config);
  })
  .catch((error) => {
    console.error('Критична помилка — навіть резервна конфігурація недоступна:', error);
  });

import { readFile, unlink } from 'node:fs/promises';

const tempFile = './temp-data.json';

readFile(tempFile, 'utf-8')
  .then((content) => {
    const data = JSON.parse(content);
    console.log('Дані оброблено:', data);
  })
  .catch((error) => {
    console.error('Помилка обробки:', error);
  })
  .finally(() => {
    // Видаляємо тимчасовий файл у будь-якому випадку
    return unlink(tempFile)
      .then(() => console.log('Тимчасовий файл видалено'))
      .catch((error) => console.warn('Не вдалося видалити файл:', error));
  });

import { readFile as readFileCallback, writeFile as writeFileCallback } from 'node:fs';
import { promisify } from 'node:util';

// Перетворюємо callback-based функції у Promise-based
const readFile = promisify(readFileCallback);
const writeFile = promisify(writeFileCallback);

// Тепер можна використовувати з промісами
readFile('./input.txt', 'utf-8')
  .then((content) => {
    const uppercased = content.toUpperCase();
    return writeFile('./output.txt', uppercased, 'utf-8');
  })
  .then(() => {
    console.log('Файл оброблено та збережено');
  })
  .catch((error) => {
    console.error('Помилка:', error);
  });

function customPromisify<T>(fn: Function): (...args: any[]) => Promise<T> {
  return function (...args: any[]): Promise<T> {
    return new Promise<T>((resolve, reject) => {
      // Додаємо callback як останній аргумент
      fn(...args, (error: Error | null, result?: T) => {
        if (error) {
          reject(error);
        } else {
          resolve(result as T);
        }
      });
    });
  };
}

// Використання
import { readFile as readFileCallback } from 'node:fs';

const readFile = customPromisify<string>(readFileCallback);

readFile('./test.txt', 'utf-8')
  .then((content) => console.log('Контент:', content))
  .catch((error) => console.error('Помилка:', error));

console.log('1. Початок');

const instantPromise = Promise.resolve('Миттєвий результат');

instantPromise.then((result) => {
  console.log('3. Обробник .then():', result);
});

console.log('2. Після реєстрації обробника');

// Вивід:
// 1. Початок
// 2. Після реєстрації обробника
// 3. Обробник .then(): Миттєвий результат

import { readFile, writeFile } from 'node:fs/promises';

// ❌ ПОМИЛКА: немає return
readFile('./input.txt', 'utf-8')
  .then((content) => {
    writeFile('./output.txt', content.toUpperCase(), 'utf-8'); // Проміс не повертається!
  })
  .then(() => {
    console.log('Готово'); // Виконається ДО завершення writeFile!
  });

// ✅ ПРАВИЛЬНО: повертаємо проміс
readFile('./input.txt', 'utf-8')
  .then((content) => {
    return writeFile('./output.txt', content.toUpperCase(), 'utf-8');
  })
  .then(() => {
    console.log('Готово'); // Виконається ПІСЛЯ завершення writeFile
  });

// ❌ АНТИПАТТЕРН: Promise Hell (вкладеність)
readFile('./config.json', 'utf-8')
  .then((content) => {
    const config = JSON.parse(content);
    
    connectToDatabase(config).then((client) => {
      client.query('SELECT * FROM users').then((result) => {
        console.log('Користувачі:', result.rows);
      });
    });
  });

// ✅ ПРАВИЛЬНО: плоский ланцюжок
readFile('./config.json', 'utf-8')
  .then((content) => JSON.parse(content))
  .then((config) => connectToDatabase(config))
  .then((client) => client.query('SELECT * FROM users'))
  .then((result) => console.log('Користувачі:', result.rows))
  .catch((error) => console.error('Помилка:', error));

// ❌ ПОМИЛКА: немає .catch()
readFile('./important-data.json', 'utf-8')
  .then((content) => JSON.parse(content))
  .then((data) => processData(data)); // Якщо processData провалиться — unhandled rejection!

// ✅ ПРАВИЛЬНО: завжди обробляємо помилки
readFile('./important-data.json', 'utf-8')
  .then((content) => JSON.parse(content))
  .then((data) => processData(data))
  .catch((error) => {
    console.error('Помилка обробки даних:', error);
    // Можна надіслати сповіщення, записати у лог тощо
  });

const resolvedPromise = Promise.resolve(42);
resolvedPromise.then((value) => console.log(value)); // 42

const rejectedPromise = Promise.reject(new Error('Щось не так'));
rejectedPromise.catch((error) => console.error(error.message)); // Щось не так

function validateUser(user: any): Promise<any> {
  if (!user.email) {
    return Promise.reject(new Error('Email є обов\'язковим'));
  }
  
  if (!user.name) {
    return Promise.reject(new Error('Ім\'я є обов\'язковим'));
  }
  
  // Якщо валідація пройшла — повертаємо проміс з користувачем
  return Promise.resolve(user);
}

import { readFile } from 'node:fs/promises';

const filePromises = [
  readFile('./file1.txt', 'utf-8'),
  readFile('./file2.txt', 'utf-8'),
  readFile('./file3.txt', 'utf-8'),
];

Promise.all(filePromises)
  .then((contents) => {
    console.log('Файл 1:', contents[0]);
    console.log('Файл 2:', contents[1]);
    console.log('Файл 3:', contents[2]);
  })
  .catch((error) => {
    console.error('Помилка читання одного з файлів:', error);
  });

const promises = [
  Promise.resolve(42),
  Promise.reject(new Error('Помилка')),
  Promise.resolve('Успіх'),
];

Promise.allSettled(promises)
  .then((results) => {
    results.forEach((result, index) => {
      if (result.status === 'fulfilled') {
        console.log(`Проміс ${index}: виконано зі значенням`, result.value);
      } else {
        console.log(`Проміс ${index}: відхилено з помилкою`, result.reason);
      }
    });
  });

// Вивід:
// Проміс 0: виконано зі значенням 42
// Проміс 1: відхилено з помилкою Error: Помилка
// Проміс 2: виконано зі значенням Успіх

const timeout = new Promise((_, reject) => {
  setTimeout(() => reject(new Error('Timeout після 5 секунд')), 5000);
});

const dataFetch = fetch('https://api.example.com/data').then((res) => res.json());

Promise.race([dataFetch, timeout])
  .then((data) => console.log('Дані отримано:', data))
  .catch((error) => console.error('Помилка або таймаут:', error));

import { readFile } from 'node:fs/promises';

interface Config {
  apiUrl: string;
  timeout: number;
  retries: number;
}

function loadConfigFromFile(path: string): Promise<Config> {
  return readFile(path, 'utf-8').then((content) => JSON.parse(content));
}

function loadConfigFromEnv(): Promise<Config> {
  if (!process.env.API_URL) {
    return Promise.reject(new Error('API_URL не встановлено'));
  }
  
  return Promise.resolve({
    apiUrl: process.env.API_URL,
    timeout: parseInt(process.env.TIMEOUT || '5000', 10),
    retries: parseInt(process.env.RETRIES || '3', 10),
  });
}

function getDefaultConfig(): Promise<Config> {
  return Promise.resolve({
    apiUrl: 'https://api.example.com',
    timeout: 5000,
    retries: 3,
  });
}

// Спроба завантажити конфігурацію з кількох джерел з fallback
function loadConfig(): Promise<Config> {
  return loadConfigFromFile('./config.json')
    .catch((error) => {
      console.warn('Не вдалося завантажити config.json:', error.message);
      return loadConfigFromEnv();
    })
    .catch((error) => {
      console.warn('Не вдалося завантажити з ENV:', error.message);
      return getDefaultConfig();
    })
    .then((config) => {
      console.log('Конфігурація завантажена:', config);
      return config;
    });
}

// Використання
loadConfig()
  .then((config) => {
    // Запуск застосунку з конфігурацією
    console.log('Застосунок стартує з URL:', config.apiUrl);
  })
  .catch((error) => {
    // Цей catch спрацює лише якщо навіть getDefaultConfig провалиться
    console.error('Критична помилка завантаження конфігурації:', error);
    process.exit(1);
  });