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

@Injectable()
export class AuthService {

    constructor(private userService: UserService, private jwtService: JwtService) { }

    private signToken(payload: any, type: 'accessToken' | 'refreshToken') {
        const config = Utility.jwtConfig[type];
        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) {
            return null;
        }
    }

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

    async login(user: any) {
        const { password, ...rest } = user;
        const payload = { rest };
        const accessToken = this.signToken(payload, 'accessToken');
        const refreshToken = this.signToken(payload, 'refreshToken');
        await RefreshToken.create({ email: user.email, token: refreshToken, type: 'jwt' });
        return {
            access_token: accessToken,
            refresh_token: refreshToken,
        };
    }

    async signup(user: any) {
        const { password, ...rest } = user;
        const payload = { rest };
        const accessToken = this.signToken(payload, 'accessToken');
        const refreshToken = this.signToken(payload, 'refreshToken');
        await RefreshToken.create({ email: user.email, token: refreshToken, type: 'jwt' });
        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');
        }
        const user = await this.userService.findByEmail(payload.email);
        if (!user) {
            throw new Error('User not found');
        }
        const { password, ...rest } = user;
        const newPayload = { rest };
        const accessToken = this.signToken({ newPayload }, 'accessToken');
        return { access_token: accessToken };
    }

    async verifyRefreshToken(refreshToken: string) {
        const payload = this.verifyToken(refreshToken, 'refreshToken');
        return payload;
    }

    async verifyAccessToken(accessToken: string) {
        const payload = this.verifyToken(accessToken, 'accessToken');
        return payload;
    }

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


    //google services

    async googleOauthRedirect(user) {
        console.log("user in service is", user);
        if (!user.email) {
            return {
                statusCode: 400,
                message: 'User not found'
            }
        }
        console.log("user.email in service is", user.email);
        let existingUser = await User.findOne({ where: { email: user.email } });
        if (!existingUser) {
            existingUser = await User.create({
                email: user.email,
                name: user.name,
                userTypeCode: 'user'
            });

        }

        const payload = existingUser.get();
        const { password, ...rest } = payload
        const accessToken =  this.signToken(rest, 'accessToken');
        const refreshToken =  this.signToken(rest, 'refreshToken');
        await RefreshToken.create({ email: payload.email, token: refreshToken, type: 'jwt' });
        return {
            statusCode: 200,
            access_token: accessToken,
            refresh_token: refreshToken
        }
    }
}