functions.js

const fs = require('fs');
const pathNode = require('node:path');
const marked = require('marked');
const fetch = require('node-fetch');

// Validar si la ruta es absoluta, sino se convierte en relativa
const getAbsolutePath = (userPath) => {
let pathAbsolute = '';
if(!userPath){
    return false
}
if(pathNode.isAbsolute(userPath)){
        pathAbsolute = userPath;
}else{
        pathAbsolute = pathNode.resolve(userPath)
}
return pathAbsolute
}

// Obtener Archivos de una carpeta
const getFiles = (path) => {
    let files = []
        if(fs.statSync(path).isFile()){
            files.push(path)
        }
        else if(fs.statSync(path).isDirectory()){
            const filesInDir = fs.readdirSync(path)
            filesInDir.forEach( file => {
                    const pathDir = pathNode.join(path, file)
                    files = files.concat(getFiles(pathDir))
            })
        }
    return files
}

// Filtar archivos md
const getMdFiles = (arrayFiles) => {
    const mdFiles = arrayFiles.filter( file => pathNode.extname(file) === '.md')
    return mdFiles
}

// Leer Archivos md y obtener links
const readFiles = (file) => {
    return new Promise ((resolve, reject)=>{
        let links = []
        fs.readFile(file, 'utf8', (err, data)=>{
                if (err) {
                    console.log('error', err) ;
                    reject(err)
                } else {
                    // resolve(data)
                    let renderer = new marked.Renderer();
                    renderer.link = function (href, title, text) {
                      if (href.includes('http')) {
                        links.push({
                          file: file,
                          href: href,
                          text: text,
                        });
                      }
                    };
                    marked.marked(data, { renderer: renderer });
                    resolve(links);
                }
            })
            return Promise.all(links).then((res) => res.flat());
    })
}

// Iterar en el array de archivos y retornar promesas 
const loopFilesMd = (arrayMd) => {
    let arrayPromises =  arrayMd.map((file)=>{
        return readFiles(file)
    })
    return Promise.all(arrayPromises).then(res=>res.flat())
}

// Validar Links 
const httpLinks = (allLinks) => {
let promisesLinks = allLinks.map( link => {
    return fetch(link.href) 
    .then(res => {
        if (res.status >= 200 && res.status < 400){
            return ({ href: link.href,
                      file: link.file, 
                      text: link.text, 
                      status: res.status, 
                      OK: res.statusText })
        }
        else if( res.status >= 400 && res.status < 600){
            return ({ href: link.href,
                file: link.file, 
                text: link.text, 
                status: res.status, 
                OK: "fail" })
        }
    })
})
    return Promise.all(promisesLinks)
}

// Encontrar Links Unicos
const getUniqueLinks = (arrayLinks) =>{
    const uniqueLinks = arrayLinks.reduce((counter, link)=>{
        counter[link.href] = ++counter[link.href] || 0
        return counter
    }, {})
    
    const linksDuplicates = arrayLinks.filter( (link) =>{
        return uniqueLinks[link.href]} )
        const linksUniques =  arrayLinks.length - linksDuplicates.length
        return linksUniques
}


// Estadisticas de funciones 
const statsLinks = (links) => {
 const total = {
       'Total' : links.length,
       'Unique' : getUniqueLinks(links)   
    }
   
    return total
   }

// validar links en estadisticas
const validateStatsLinks = (links)=>{
    const linksBrokens = links.filter( link => link.OK === 'fail' )

    const total = {
        'Total' : links.length,
        'Unique' : getUniqueLinks(links), 
        'Broken' : linksBrokens.length
     }

     return total
}

module.exports = {
    getAbsolutePath,
    getFiles,
    getMdFiles,
    loopFilesMd,
    httpLinks,
    statsLinks,
    validateStatsLinks,
    getUniqueLinks
}