Promise와 async/await

// Promise 생성: Promise 생성자는 resolve와 reject 두 콜백 함수를 인자로 받습니다.
const myPromise = new Promise<string>((resolve, reject) => {
  // 비동기 작업 수행 (예: setTimeout으로 2초 후 성공)
  setTimeout(() => {
    const success = true; // 실제로는 서버 응답이나 다른 조건에 따라 결정

    if (success) {
      resolve("데이터를 성공적으로 가져왔습니다!"); // 작업 성공 시 호출
    } else {
      reject("데이터를 가져오는 데 실패했습니다."); // 작업 실패 시 호출
    }
  }, 2000);
});

// Promise 사용: .then()으로 성공 시 처리, .catch()로 실패 시 처리
myPromise
  .then((message: string) => {
    console.log("성공:", message); // '데이터를 성공적으로 가져왔습니다!'
  })
  .catch((error: string) => {
    console.error("실패:", error); // '데이터를 가져오는 데 실패했습니다.'
  });

console.log("Promise 작업 시작 (비동기적으로 실행됩니다)"); // 이 부분이 먼저 출력됩니다.

function fetchData(url: string): Promise<string> {
  return new Promise((resolve) => {
    setTimeout(() => {
      console.log(`[1] ${url} 에서 데이터 가져오기 완료`);
      resolve(`Fetched data from ${url}`);
    }, 1000);
  });
}

function processData(data: string): Promise<string> {
  return new Promise((resolve) => {
    setTimeout(() => {
      console.log(`[2] 데이터 처리 완료: ${data}`);
      resolve(`Processed: ${data.toUpperCase()}`);
    }, 1500);
  });
}

function saveData(processedData: string): Promise<string> {
  return new Promise((resolve) => {
    setTimeout(() => {
      console.log(`[3] 데이터 저장 완료: ${processedData}`);
      resolve("모든 작업 완료!");
    }, 800);
  });
}

// Promise 체이닝
fetchData("api/users")
  .then((data) => processData(data)) // 첫 번째 Promise의 결과가 다음 Promise의 인자로 전달
  .then((processedData) => saveData(processedData)) // 두 번째 Promise의 결과가 다음 Promise의 인자로 전달
  .then((finalMessage) => {
    console.log(finalMessage); // '모든 작업 완료!'
  })
  .catch((error) => {
    console.error("체인 중 오류 발생:", error);
  });

console.log("비동기 체인 시작...");

function mightFailFetch(): Promise<string> {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      const shouldFail = Math.random() > 0.5;
      if (shouldFail) {
        reject("네트워크 오류 발생!");
      } else {
        resolve("데이터 성공적으로 가져옴.");
      }
    }, 500);
  });
}

mightFailFetch()
  .then((data) => {
    console.log("데이터:", data);
    return Promise.resolve("다음 처리"); // 성공적으로 다음 .then()으로 전달
  })
  .then((nextData) => {
    console.log("다음 처리:", nextData);
    // return Promise.reject("처리 중 의도적인 오류!"); // 여기서 오류를 발생시킬 수도 있습니다.
  })
  .catch((error) => {
    console.error("오류 발생:", error); // 체인 중 발생한 모든 오류를 여기서 처리
  })
  .finally(() => { // Promise가 성공하든 실패하든 항상 실행
    console.log("작업 종료 (finally 블록)");
  });

// async 함수는 항상 Promise를 반환합니다.
async function fetchUserData(): Promise<string> {
  console.log("[1] 사용자 데이터 가져오기 시작...");
  // await은 Promise가 완료될 때까지 기다립니다.
  const response = await new Promise<string>((resolve) => {
    setTimeout(() => {
      resolve("사용자 정보: Alice");
    }, 1500);
  });

  console.log("[2] 사용자 데이터 가져오기 완료:", response);
  return response;
}

async function processAndSaveUserData(): Promise<void> {
  try {
    const userData = await fetchUserData(); // fetchUserData가 완료될 때까지 기다림
    console.log("[3] 데이터 처리 중...");
    await new Promise<void>((resolve) => setTimeout(resolve, 1000)); // 처리 시간 시뮬레이션
    console.log(`[4] ${userData} 처리 완료.`);

    console.log("[5] 데이터 저장 중...");
    await new Promise<void>((resolve) => setTimeout(resolve, 800)); // 저장 시간 시뮬레이션
    console.log(`[6] ${userData} 저장 완료.`);
  } catch (error) {
    console.error("오류 발생:", error); // try-catch로 오류 처리
  } finally {
    console.log("[7] 모든 작업 완료 (async/await finally)");
  }
}

console.log("비동기 함수 호출 시작...");
processAndSaveUserData(); // async 함수를 호출하면 즉시 Promise가 반환됩니다.
console.log("비동기 함수 호출 완료 (실행은 계속됩니다)...");

async function riskyOperation(): Promise<string> {
  const willFail = Math.random() > 0.5;
  if (willFail) {
    throw new Error("위험한 작업 실패!"); // async 함수에서 throw는 Promise.reject()와 동일
  }
  return "위험한 작업 성공!";
}

async function performRiskyTask(): Promise<void> {
  try {
    console.log("위험한 작업 시작...");
    const result = await riskyOperation(); // 실패하면 여기서 catch 블록으로 점프
    console.log("결과:", result);
  } catch (error: any) { // 'any' 대신 'unknown'을 사용하는 것이 더 안전합니다 (TS 4.4+).
    console.error("작업 중 오류:", error.message);
  } finally {
    console.log("위험한 작업 시도 종료.");
  }
}

performRiskyTask();
performRiskyTask(); // 여러 번 실행하여 성공/실패 확인

async function greet(name: string): Promise<string> {
  return `Hello, ${name}!`; // Promise.resolve('Hello, Alice!') 와 동일
}

greet("Alice").then(message => console.log(message)); // Hello, Alice!

async function throwError(): Promise<never> { // 'never'는 이 함수가 값을 반환하지 않고 항상 예외를 던짐을 의미
  throw new Error("Something went wrong!"); // Promise.reject(new Error("...")) 와 동일
}

throwError().catch(error => console.error(error.message)); // Something went wrong!

async function fetchPost(id: number): Promise<any> {
  console.log(`Fetching post ${id}...`);
  return new Promise(resolve => setTimeout(() => resolve({ id, title: `Post ${id} Title` }), 1000));
}

async function fetchComments(postId: number): Promise<any> {
  console.log(`Fetching comments for post ${postId}...`);
  return new Promise(resolve => setTimeout(() => resolve([{ id: 1, text: "Comment 1" }, { id: 2, text: "Comment 2" }]), 1500));
}

async function loadPostAndComments(postId: number): Promise<void> {
  try {
    console.log("Loading post and comments concurrently...");
    // 두 Promise를 동시에 시작하고 모두 완료될 때까지 기다립니다.
    const [post, comments] = await Promise.all([
      fetchPost(postId),
      fetchComments(postId)
    ]);

    console.log("\n--- All data loaded ---");
    console.log("Post:", post);
    console.log("Comments:", comments);
  } catch (error) {
    console.error("Error loading data:", error);
  }
}

loadPostAndComments(1);