// auth/auth.controller.ts
@Get('github/signin')
signInWithGithub(@Res({ passthrough: true }) res: Response) {
	res.redirect(
		`https://github.com/login/oauth/authorize?client_id=${process.env.OAUTH_GITHUB_CLIENT_ID}&scope=read:user%20user:email`,
	);
}

// auth/auth.controller.ts
@Get('github/callback')
async oauthGithubCallback(@Query('code') code: string) {
	await this.authService.oauthGithubCallback(code);
}

// utils/auth.util.ts

// AccessToken을 가져오는 메소드
export async function getGitHubAccessToken(authorizedCode: string) {
	const accessTokenResponse = await fetch(  // AccessToken을 받아오기 위해 깃헙에 fetch
		'https://github.com/login/oauth/access_token',
		{
			method: 'POST',  // POST 요청
			headers: {
				Accept: 'application/json',
				'Content-Type': 'application/json',
			},
			// OAuth Apps를 생성할 때 기억한 Client ID, Client SECRETS와 Authorized Code를 넘겨준다.
			body: JSON.stringify({  
				client_id: process.env.OAUTH_GITHUB_CLIENT_ID,
				client_secret: process.env.OAUTH_GITHUB_CLIENT_SECRETS,
				code: authorizedCode,
			}),
		},
	);

	if (!accessTokenResponse.ok) {  // 받아온 응답이 200 OK가 아니라면 에러 발생
		throw new InternalServerErrorException(
			'GitHub으로부터 accessToken을 받아오지 못했습니다.',
		);
	}

	const accessTokenData = await accessTokenResponse.json();
	return accessTokenData.access_token;  // 응답에서 AccessToken을 리턴
}

// 유저 정보를 가져오는 메소드
export async function getGithubUserData(accessToken: string) {
	const userResponse = await fetch('https://api.github.com/user', {  // 유저 정보를 받아오기 위해 깃헙에 fetch
		method: 'GET',  // GET 요청
		headers: {
			Authorization: `Bearer ${accessToken}`,  // Authorization Bearer 토큰으로 AccessToken을 넘겨준다.
		},
	});

	if (!userResponse.ok) {  // 받아온 응답이 200OK가 아니라면
		throw new InternalServerErrorException(
			'GitHub으로부터 유저 정보를 받아오지 못했습니다.',
		);
	}

	const userData = await userResponse.json();
	return {  // 응답에서 깃헙 닉네임을 리턴 (깃헙 닉네임을 username 으로 데이터베이스에 저장할 예정)
		username: userData.login,
	};
}

// auth/auth.service.ts
async oauthGithubCallback(code: string) {
	if (!code) {  // 만약 code가 넘어오지 않았다면 에러
		throw new BadRequestException('Authorized Code가 존재하지 않습니다.');
	}

	const accessToken = await getGitHubAccessToken(code);
	const githubUser = await getGithubUserData(accessToken);
	console.log(githubUser);
}

// auth/auth.service.ts
async oauthGithubCallback(authorizedCode: string) {
		if (!authorizedCode) {
			throw new BadRequestException('Authorized Code가 존재하지 않습니다.');
		}

		const gitHubAccessToken = await getGitHubAccessToken(authorizedCode);
		const gitHubUser = await getGitHubUserData(gitHubAccessToken);

		// GitHubUsername으로 데이터베이스 조회
		const user = await this.authRepository.findOneBy({  
			username: gitHubUser.username,
		});

		if (!user) {  // 만약 조회되는 유저가 없다면(회원가입을 완료하지 않은 유저라면)
			// Redis에 GitHubUsername을 키로하여 AccessToken 저장
			this.redisRepository.set(gitHubUser.username, gitHubAccessToken);
			return {  // username 정보 반환
				username: gitHubUser.username,
				accessToken: null,
				refreshToken: null,
			};
		}

		// 만약 조회되는 유저가 있다면(이미 가입을 완료한 깃헙 로그인 유저라면) 토큰 발급
		const [accessToken, refreshToken] = await Promise.all([
			createJwt(user, JwtEnum.ACCESS_TOKEN_TYPE, this.jwtService),
			createJwt(user, JwtEnum.REFRESH_TOKEN_TYPE, this.jwtService),
		]);

		this.redisRepository.set(user.username, refreshToken);

		return {  // 토큰 정보 반환
			username: null,
			accessToken,
			refreshToken,
		};
	}
}

// auth/auth.controller.ts
@Get('github/callback')
async oauthGithubCallback(
	@Query('code') authorizedCode: string,
	@Res({ passthrough: true }) res: Response,
) {
	const { username, accessToken, refreshToken } =  // Service 로직 결과 받아옴
		await this.authService.oauthGithubCallback(authorizedCode);
	if (username) {  // username 값이 있다면 (회원가입을 완료하지 않은 유저라면)
		res.cookie('GitHubUsername', username, {  // 쿠키에 GitHubUsername 저장
			path: '/',
			httpOnly: true,
		});
		return { username };
	}

	// username 값이 없다면 (이미 회원 가입을 완료한 유저라면) 쿠키에 JWT 저장
	res.cookie(JwtEnum.ACCESS_TOKEN_COOKIE_NAME, accessToken, {
		path: '/',
		httpOnly: true,
	});
	res.cookie(JwtEnum.REFRESH_TOKEN_COOKIE_NAME, refreshToken, {
		path: '/',
		httpOnly: true,
	});

	return { accessToken, refreshToken };
}

// auth/auth.service.ts
async signUpWithGithub(nickname: string, GitHubUsername: any) {
	let gitHubUserData;
	try {  
		// GitHubUsername으로 Redis에서 GitHub AccessToken 가져옴
		const gitHubAccessToken = await this.redisRepository.get(GitHubUsername);
		// 토큰을 이용해 깃헙으로 다시 유저 정보 조회 요청
		gitHubUserData = await getGitHubUserData(gitHubAccessToken);
	} catch (e) {  // AccessToken이 잘못되어 유저 정보를 받아오지 못했다면 에러
		throw new UnauthorizedException('잘못된 접근입니다.');
	}
	
	// 새로 조회한 username과 쿠키에 저장되었던 username이 다르다면 에러
	if (gitHubUserData.username !== GitHubUsername) {
		throw new UnauthorizedException('잘못된 접근입니다.');
	}

	// 유저 정보가 일치한다면 Redis에 저장했던 AccessToken 정보 제거
	this.redisRepository.del(GitHubUsername);

	// 데이터베이스에 저장할 정보 생성
	const newUser = this.authRepository.create({
		username: GitHubUsername,
		password: uuid(),  // 비밀번호는 uuid
		nickname,  // 클라이언트에서 설정해 받아온 닉네임
	});

	const savedUser: User = await this.authRepository.save(newUser);  // 데이터베이스에 저장
	savedUser.password = undefined;
	// 패스워드 가리고 반환
	return savedUser;
}

// auth/auth.controller.ts
@Post('github/signup')
async signUpWithGithub(
	@Body('nickname') nickname: string,
	@Req() req,
	@Res({ passthrough: true }) res: Response,
) {
	let gitHubUsername;
	try {  // 만약 쿠키에 username 정보가 없다면 에러
		gitHubUsername = req.cookies.GitHubUsername;
	} catch (e) {
		throw new UnauthorizedException('잘못된 접근입니다.');
	}
	
	// 서비스 로직 실행
	const savedUser = await this.authService.signUpWithGithub(
		nickname,
		gitHubUsername,
	);
	
	// 쿠키 제거
	res.clearCookie('GitHubUsername', {
		path: '/',
		httpOnly: true,
	});

	return savedUser;
}