export const backendConfig = (): TypeInput => {

    const DiscordProvider = ThirdPartyNode.Discord({
        clientId: ``,
        clientSecret: ``,
        scope: ['identify', 'guilds'],
    })

    return {
        framework: "express",
        supertokens: {
            // These are the connection details of the app you created on supertokens.com
            connectionURI: "",
            apiKey: "",
        },
        appInfo,
        recipeList: [
            ThirdPartyNode.init({
                signInAndUpFeature: {
                    providers: [
                        {
                            ...DiscordProvider,
                            get: (redirectURI, authCodeFromRequest, userContext) => {
                                try {
                                    let result = DiscordProvider.get(redirectURI, authCodeFromRequest, userContext);
                                    return {
                                        ...result,
                                        getProfileInfo: async (accessTokenAPIResponse: {
                                            access_token: string,
                                            expires_in: number,
                                            token_type: string
                                        }) => {
                                            let accessToken = accessTokenAPIResponse.access_token;
                                            let authHeader = `Bearer ${accessToken}`;
                                            let response = await axios({
                                                method: "get",
                                                url: "https://discord.com/api/users/@me",
                                                headers: {
                                                    Authorization: authHeader,
                                                },
                                            });
                                            let userInfo = response.data as any;
                                            let username = userInfo.id // fetch username from discord
                                            return {
                                                id: userInfo.id,
                                                email:
                                                /*userInfo.email === undefined
                                                    ? undefined
                                                    :*/ {
                                                    id: username + "@example.com", // doesn't really matter
                                                    isVerified: true,
                                                },
                                            };
                                        },
                                    }
                                } catch (ex) {
                                    throw Sentry.captureException(ex)
                                }
                            },
                        }
                    ],
                },
                override: {
                    apis: (originalImplementation) => {
                        return {
                            ...originalImplementation,

                            signInUpPOST: async function (input) {
                                try {

                                    if (originalImplementation.signInUpPOST === undefined) {
                                        throw Error("Should never come here");
                                    }

                                    let response = await originalImplementation.signInUpPOST(input)

                                    //console.log(response)

                                    if (response.status === "OK") {

                                        // In this example we are using Google as our provider
                                        //let accessToken = response.authCodeResponse.access_token

                                        let userInfo = await axios.get<{
                                            id: string,
                                            username: string,
                                            avatar: string,
                                            avatar_decoration: string | null,
                                            discriminator: string,
                                            public_flags: number,
                                            flags: number,
                                            banner: string | null,
                                            banner_color: string,
                                            accent_color: number,
                                            locale: string,
                                            mfa_enabled: boolean
                                        }>(`https://discord.com/api/users/@me`, {
                                            headers: {
                                                Authorization: `${response.authCodeResponse.token_type} ${response.authCodeResponse.access_token}`
                                            }
                                        })

                                        let guilds = await axios.get<any>(`https://discord.com/api/users/@me/guilds`, {
                                            headers: {
                                                Authorization: `${response.authCodeResponse.token_type} ${response.authCodeResponse.access_token}`
                                            }
                                        })

                                        await UserMetadata.updateUserMetadata(response.session.getUserId(), {
                                            username: userInfo.data.username,
                                            userId: userInfo.data.id,
                                            avatarId: userInfo.data.avatar,
                                            avatar: `https://cdn.discordapp.com/avatars/${userInfo.data.id}/${userInfo.data.avatar}`,
                                            guilds: await Promise.all(guilds.data.map(async (g: any) => {
                                                return {
                                                    ...g,
                                                    setup: (await mongo.db(`index`).collection(`discord`).findOne({ _id: g.id })) !== null,
                                                    iconURL: `https://cdn.discordapp.com/icons/${g.id}/${g.icon}.png`
                                                }
                                            })),
                                            discordAuthHeader: Encrypt(`${response.authCodeResponse.token_type} ${response.authCodeResponse.access_token}`, userInfo.data.id)
                                        });

                                    }

                                    return response;
                                } catch (ex) {
                                    throw Sentry.captureException(ex)
                                    //throw ex
                                    //@ts-ignore
                                    //return await originalImplementation.signInUpPOST(input)

                                }
                            },
                        }
                    }
                },
            }),
            SessionNode.init(),
            UserMetadata.init()
        ],
        isInServerlessEnv: true,
    }
}