let parentTabs = [];
let validTabs = [];
let tabsPromises = []
// let historyPath = [];
// let createdTabData = {};
// let popUnder = false;
// let ads = {};
// let parentTab = [];
// let parentTabChange = [];

// const recursiveSearch = (tabInList, currentTab) => {
//     if (isNextExist(tabInList)) {
//         return recursiveSearch(tabInList.next, currentTab)
//     }
//     return tabInList.next = { url: currentTab.url }
// };

// const isNextExist = tab => {
//     if (tab) {
//         const isNext = Object.keys(tab).filter(elem => elem === "next")
//         if (isNext.length === 1) return true;
//     }
//     return false;
// }

// const isIdExist = id => {
//     if (allTabs[id]) return true;
//     return false;
// };

const verifyTab = async (tab) => {
    // debugger
    let response = await fetch('http://localhost:3000/watch', {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json'
        },
        body: JSON.stringify(tab)
    })
    let data = await response.json();
    return data;
}

const traceTab = async tab => {
    let response = await fetch('http://localhost:3000/trace', {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json'
        },
        body: JSON.stringify(tab)
    })
}

// const isTabNeeded = (tabId) => {
//     let isAlreadyFind = false;
//     let detectedTab;
//     validTabs.forEach(elem => {
//         if (!isAlreadyFind) {
//             if (elem.id === tabId) {
//                 isAlreadyFind = true;
//                 detectedTab = elem;
//             }
//             else if (elem.childs.length > 0) {
//                 elem.childs.forEach(childElem => {
//                     if (childElem.id === tabId) {
//                         isAlreadyFind = true;
//                         detectedTab = childElem;
//                         detectedTab.isChildren = true;
//                     }
//                 });
//             }
//         }
//     });
//     return detectedTab;
// };

// chrome.tabs.query({currentWindow: true }, async function(tabs) {
//     Object.values(tabs).map(tab => {
//         return allTabs.push({ id: tab.id, url: tab.url, parentUrl: '', path: [], childs : [] });
//     })
//     validTabs = await verifyTabs();
// });

// chrome.history.onVisited.addListener(function(data) {
//     debugger
//         historyPath.push(data.url);
// });

const getValidTab = async id => {
    let isAlreadyFind = false;
    let detectedTab;
    for (const elem of parentTabs) {
        if (!isAlreadyFind) {
            if (elem.id === id) {
                isAlreadyFind = true;
                if (elem.isPending) await elem.promise;
                if (elem.isValid) {
                    detectedTab = elem;
                } else {
                    detectedTab = null;
                }
            }
            else if (elem.childs.length > 0) {
                for (const childElem of elem.childs) {
                    if (childElem.id === id) {
                        if (elem.isPending) await elem.promise
                        // debugger
                        childElem.parentUrl = elem.url;
                        isAlreadyFind = true;
                        detectedTab = childElem;
                    }
                }
                // elem.childs.forEach(async childElem => {
                //     if (childElem.id === id) {
                //         if (elem.isPending) await elem.promise
                //         debugger
                //         childElem.parentUrl = elem.url;
                //         isAlreadyFind = true;
                //         detectedTab = childElem;
                //     }
                // });
            }
        }
    }
    return detectedTab;
    // let tab = parentTabs.find(elem => elem.id === id);
    // if (!tab.promise) {
    //     tab.promise = new Promise((resolve, reject) => {
    //         chrome.tabs.get(id, async function(tab){
    //             debugger;
    //             let data = await verifyTab(tab)
    //             if (data.length > 0) resolve({ id: tab.id, url: tab.url, parentUrl: '', path: [], childs : [] });
    //         });
    //     });
    // }
};

chrome.webRequest.onBeforeRedirect.addListener(async function(details) {
    // debugger
    if (details.type === 'main_frame'){
        const adsTab = await getValidTab(details.tabId);
        if (adsTab) {
            adsTab.path.push({code: details.statusCode, url: details.url})
        }
    }
}, {urls: ["<all_urls>"]}
);

chrome.webRequest.onCompleted.addListener(async function(details) {
    // debugger
    if (details.type === 'main_frame'){
        const adsTab = await getValidTab(details.tabId);
        // debugger
        if (adsTab) {
            adsTab.path.push({code: details.statusCode, url: details.url})
        }
    }
}, {urls: ["<all_urls>"]}
);

chrome.tabs.onCreated.addListener(function(tab) {
    // debugger
    let parent = parentTabs.find(elem => elem.id === tab.openerTabId);
    if (!parent) {
        const promise = new Promise((resolve, reject) => {
            chrome.tabs.get(tab.openerTabId, async function(tab){
                // debugger;
                const parent = parentTabs.find(elem => elem.id === tab.id);
                parent.url = tab.url;
                let data = await verifyTab(tab)
                parent.isPending = false;
                if (data.length > 0) {
                    parent.isValid = true;
                    resolve("Valid");
                } else reject("Not Valid");
            });
        });
        parent = {
            id: tab.openerTabId,
            isPending: true,
            path: [],
            childs: [],
            isValid: false,
            promise
        };
        parentTabs.push(parent);
    }
    parentTabs.forEach(parent => {
        parent.childs = parent.childs.filter(child => child.id !== tab.openerTabId);
    });
    parent.childs.push({ id: tab.id, url: tab.url, parentUrl: "", path: [], isChildren: true });
    // let parentTab = await getTab(tab.openerTabId);
    // //validTabs = await verifyTabs(parentTab);

    // let parent = validTabs.filter(elem => elem.id === tab.openerTabId);
    // if (parent.length > 0) {
    //     // parentTab = JSON.parse(JSON.stringify(parent));
    //     // parentTabChange = parent;
    //     // createdTabData = {tabId: tab.id, status: tab.status, openerTabId: tab.openerTabId, parentUrl: parent[0].url};
    //     parent[0].childs.push({ id: tab.id, url: tab.url, parentUrl: parent[0].url, path: [], childs : []});

    // }
});

// chrome.tabs.onRemoved.addListener(function(tabId, removeInfo) {
//     debugger
//     allTabs = allTabs.filter(elem => elem.id !== tabId);
//     validTabs = validTabs.filter(elem => elem.id !== tabId);
//     validTabs.forEach(elem => {
//         if (elem.childs.length > 0) {
//             elem.childs = elem.childs.filter(childElem => childElem.id !== tabId)
//         }
//     });
//     console.log(validTabs)
// });

chrome.tabs.onUpdated.addListener(async function(tabId, changeInfo, currentTab) {
    // debugger
    // console.log(validTabs);
    //is the currentTab in validTabs
    // if (currentTab.url !== parentTab[0].url) {
        //let t = await getTab(tabId);
    if (changeInfo.status === 'complete' && currentTab.title !== 'New Tab') {
        const validTab = await getValidTab(tabId);
        if (validTab) {
            // createdTabData.status = currentTab.status;
            // createdTabData.openerTabId = currentTab.openerTabId;
            if (validTab.path.length > 0) {

                if (validTab.isChildren) {
                    if (validTab.parentUrl !== validTab.path[validTab.path.length - 1].url) traceTab({origin: validTab.parentUrl, path: validTab.path});
                } else {
                    // if (validTab.url !== validTab.path[validTab.path.length - 1].url)
                    traceTab({origin: validTab.url, path: validTab.path});
                }
                validTab.path = [];
            }
        }
    }
    // }
});

            // try {
            //     chrome.tabs.captureVisibleTab(null,{},function(dataUri){
            //         console.log(dataUri);
            //     });
            // }
            // catch(error) {
            //     console.log(error)
            // }

        // if (isNextExist(allTabs[currentTab.id])) {
        //     return recursiveSearch(allTabs[currentTab.openerTabId], currentTab)
        // }