'use strict';
import Secure from './secure.js';
import App from './app.js';
import RequestToDomain from './requests-to-domain.js';
// import * as jose from 'jose';  // per la gestione del token


const mySecure = new Secure();

let token = null;
let tokenTime = null; // momento in cui ottengo il token
let expirationTime = null; // momento a partire dal quale il token non sarà più valido
let alreadyRefreshed = false; // true se ho appena fatto la richiesta del token usando il refresh token
let oldTimeout = null;
const uri = window.location.toString();

if(!uri.includes('#')) {
    const a = document.getElementById("my-link");
    a.href = a.href.replace("$MY_CODE_CHALLENGE", mySecure.codeChallenge).replace("$MY_STATE", mySecure.state);
    sessionStorage.setItem("stateSent", mySecure.state); // state inviato durante la richiesta dell'authcode
    sessionStorage.setItem("codeVerifier", mySecure.codeVerifier);
}
else {
    // l'uri e' del tipo localhost:3000/secured# seguito da parametri
    const uriSplit = uri.split('#');
    const params = uriSplit[1].split('&');
    const uriState = queryStringGetValue(params[0]);
    const uriAuthCode = queryStringGetValue(params[2]);
    
    if(!sessionStorage.stateSent || sessionStorage.stateSent !== uriState) {
        const body = document.getElementById('body-id');
        body.innerHTML = "";
        body.innerHTML =  `Errors in the request!`; 
    }
    else {
        await requestFirstToken(uriAuthCode);  // post per la richiesta del token
        if(token !== null) {
            // console.log(token);

            tokenTime = moment();
            expirationTime = tokenTime.add(token.expires_in,'s');

            const requestsToDomain = new RequestToDomain();
            // const myDomains = await requestsToDomain.getMyDomains();
const myDomains = [{nome: "casa1", stato:"on", admin: true}, 
                   {nome: "casa2", stato:"off", admin: false},
                   {nome: "casa3", stato:"on", admin: true},
                   {nome: "casa4", stato:"on", admin: false},
                   {nome: "casa4", stato:"on", admin: false},
                   {nome: "casa4", stato:"on", admin: false},
                   {nome: "casa4", stato:"on", admin: true},
                   {nome: "casa4", stato:"on", admin: false}
]; 

            const app = new App(myDomains, requestsToDomain);
        }
            
        
    }
}

/**
     * Ottengo il valore associato al parametro. 
     * @param {*} queryString query string del tipo parametro=valore.
     * @returns il valore associato al parametro.
     */
function queryStringGetValue(queryString) {
    const arr = queryString.split('=');
    return arr[1];
}


/**
 * Post per la prima richiesta del token.
 * @returns il token ottenuto se la richiesta ha avuto successo, null altrimenti.
 */
async function requestFirstToken(uriAuthCode) {

    const url = 'http://localhost:8080/realms/test00/protocol/openid-connect/token';
    const response = await fetch(url, {
        method: 'POST',
        headers: {
            'Content-type':'application/x-www-form-urlencoded'
        },
        body: new URLSearchParams({
            grant_type: 'authorization_code',
            client_id: 'myclient',
            code_verifier: sessionStorage.getItem("codeVerifier"),
            code: uriAuthCode,
            redirect_uri: 'http://localhost:3000/secured'
        })
    });
    token = await response.json();
    if(response.ok) {
        oldTimeout = timeoutRefresh();
    }
    else
        token = null;
}


async function getToken() {
    const now = moment();
    if(now - expirationTime < 1) {
        //this token has expired, so request new token
        await requestUsingRefreshToken();
    }
    return token.access_token; 
}


/**
 * Post per la richiesta del token usando il refresh token.
 */
 async function requestUsingRefreshToken() {
    const url = 'http://localhost:8080/realms/test00/protocol/openid-connect/token';
    const response = await fetch(url, {
        method: 'POST',
        headers: {
            'Content-type':'application/x-www-form-urlencoded'
        },
        body: new URLSearchParams({
            grant_type: 'refresh_token',
            client_id: 'myclient',
            refresh_token: `${token.refresh_token}`
        })
    });
    token = await response.json();
    if(response.ok) {
        alreadyRefreshed = true;
        oldTimeout = timeoutRefresh();
    }
    else
        token = null;
}


/**
 * Prima che scada il refresh token, richiedo nuovamente il token 
 * (usando il refresh token).
 * @returns id di setTimeout()
 */
function timeoutRefresh() {
    if(oldTimeout !== null)
        clearTimeout(oldTimeout);

    return setTimeout(async () => {
        if(!alreadyRefreshed) {
            await requestUsingRefreshToken();
            alreadyRefreshed = false;
        }
    }, (token.refresh_expires_in*1000)-5000);
}


/**
 * Effettua il logout.
 */
async function logoutKeycloak() {
    clearTimeout(oldTimeout); // DA FARE: non funziona. Controllare come si fa il logout su keycloak!!!!
    const url = 'http://localhost:8080/realms/test00/protocol/openid-connect/logout?redirect_uri=http://localhost:3000/secured';
    const response = await fetch(url, {
        method: 'POST',
        headers: {
            'Authorization': `Bearer ${await getToken()}`
        }
        }
    );
    if(response.ok)
        token = null;
    else 
        throw await response.json();
}

export {getToken, logoutKeycloak};