import { Injectable } from '@nestjs/common';
import { JwtService } from '@nestjs/jwt';
import { Utility } from 'src/common/Utility';
import JwtPayload from 'src/jwt/jwt-payload.dto';
import RefreshToken from 'src/jwt/refresh-token.entity';
import { UserService } from 'src/user/user.service';

@Injectable()
export class AuthService {
    constructor(private userService: UserService, private jwtService: JwtService) { }

    private signToken(payload: any, type: 'accessToken' | 'refreshToken'): string {
        console.log("yav type andre", type)
        const config = Utility.jwtConfig[type];
        console.log("yav expiry andre", config.expiresIn)
        return this.jwtService.sign(payload, {
            secret: config.secretOrKey,
            expiresIn: config.expiresIn,
        });
    }

    private verifyToken(token: string, type: 'accessToken' | 'refreshToken'): any {
        const config = Utility.jwtConfig[type];
        try {
            return this.jwtService.verify(token, {
                secret: config.secretOrKey,
            });
        } catch (error) {
            console.log(`${type} token is invalid`, error);
            return null;
        }
    }

    async validateUser(payload: JwtPayload) {
        return this.userService.findByEmail(payload.email);
    }

    async login(user: any) {
        const payload: JwtPayload = { email: user.email, password: user.password };
        console.log("illig bandu nilthu", payload)
        const accessToken = this.signToken(payload, 'accessToken');
        console.log("illig bandu nilthu", accessToken)

        const refreshToken = this.signToken(payload, 'refreshToken');

        await RefreshToken.create({ email: user.email, token: refreshToken });

        return {
            access_token: accessToken,
            refresh_token: refreshToken,
        };
    }

    async refreshAccessToken(refreshToken: string) {
        const payload = this.verifyToken(refreshToken, 'refreshToken');
        if (!payload) {
            throw new Error('Invalid refresh token');
        }

        console.log(refreshToken);
        console.log(payload);
        const user = await this.userService.findByEmail(payload.email);
        if (!user) {
            throw new Error('User not found');
        }
        console.log(user)
        const accessToken = this.signToken({
            email: payload.email
        }, 'accessToken');
        console.log(accessToken)
        return { access_token: accessToken };
    }

    async verifyRefreshToken(refreshToken: string) {
        const payload = this.verifyToken(refreshToken, 'refreshToken');
        if (payload) {
            console.log("Refresh token is valid", payload);
        }
        return payload;
    }

    async verifyAccessToken(accessToken: string) {
        const payload = this.verifyToken(accessToken, 'accessToken');
        if (payload) {
            console.log("Access token is valid", payload);
        }
        return payload;
    }

    async logout(refreshToken: string) {
        return RefreshToken.destroy({ where: { token: refreshToken } });
    }
}