let listFiles=(auth, folderpath, savepath, filelist) => {
    //Google Drive API
    const drive = google.drive({version: 'v3', auth});
    
    //query setting for parent directories
    let folderqueryspec=null;
    folderpath.map((folder)=>{
        if(!folderqueryspec)folderqueryspec="name='"+folder+"'";
        else folderqueryspec+=" or name='"+folder+"'";
    });
    
    //delete file list
    fs.unlink(filelist, (err) => {
        if(err)console.log(err);
    });

    //get parent directory
    drive.files.list({
        q: "trashed=false and mimeType = 'application/vnd.google-apps.folder' and ("+folderqueryspec+")",
        pageSize: 5,
        fields: 'nextPageToken, files(id, name, trashed, parents)',
    }, (err, res) => {
        if (err) return console.log('The API returned an error(Folder was not found): ' + err);

        //query setting for source directories
        const parentFolders = res.data.files;
        let parentfolderqueryspec;
        parentFolders.map((folder)=>{
            if(!parentfolderqueryspec)parentfolderqueryspec="'"+folder.id+"' in parents";
            else parentfolderqueryspec+=" or '"+folder.id+"' in parents";
        });
        
        //get source directories
        drive.files.list({
            q: "trashed=false and mimeType = 'application/vnd.google-apps.folder' and ("+parentfolderqueryspec+")",
            fields: 'nextPageToken, files(id, name, trashed, parents, mimeType)',
        }, (err, res) => {
            if (err) return console.log('The API returned an error: ' + err);
            parentfolders = res.data.files;
            if (parentfolders.length) {
                parentfolders.map((folder) => {
                    //get file object under the source directories
                    drive.files.list({
                        q: "trashed=false and (mimeType contains 'text/' or mimeType contains 'image/') and '"+folder.id+"' in parents",
                        pageSize: 1000,
                        fields: 'nextPageToken, files(id, name, trashed, parents, mimeType, copyRequiresWriterPermission, webContentLink)',
                    }, (err, res) => {
                        //save a file list
                        let markdownfiles=res.data.files;
                        markdownfiles.map((file) => {
                            fs.appendFile(filelist, file.name + " " + file.id + " " + file.mimeType + " " + folder.name + " " + folder.id + "\n", (err) => {
                                if(err)console.log(err);
                            });
                        });
                    });
                });
            } else {
                console.log('No files found.');
            }
        });
    });
}

let folderpath=['hexo','source']; //Google Drive folder
let savepath='/var/www/hexo/source'; //Hexo web sources
let filelist='/var/www/hexo/tmp/sourcefiles.list'; //file list

let deleteAllFiles=(dir)=>{
    const filenames = fs.readdirSync(dir);
    filenames.forEach((filename) => {
        let excluded=false;
        excludefiles.forEach((exfile)=>{
            if(exfile===filename){
                excluded=true;
            }
        });
        if(!excluded){
            const fullPath = path.join(dir, filename);
            const stats = fs.statSync(fullPath);
            if (stats.isFile()) {
                console.log(fullPath);
                fs.unlink(fullPath);
            } else if (stats.isDirectory()) {
                deleteAllFiles(fullPath);
            }
        }
    });
}

let sleep=(waitSec) => {
    return new Promise(function (resolve) {
        setTimeout(function() { resolve() }, waitSec);
    });
} 

let listFiles=async (auth) => {
    deleteAllFiles(savepath);
    const rl=readline.createInterface({
        input: fs.createReadStream(filelist),
        //output: process.stdout,
        crlfDelay: Infinity,
    });
    rl.on('line', async (line)=>{
        let attributes=line.split(' ');
        let fileobj={
            id: attributes[1],
            name: attributes[0],
            mimeType: attributes[2],
            folderName: attributes[3],
            folderId: attributes[4],
        }
        await downloadFile(auth, fileobj);
    });
}

let downloadFile=async (auth, file) =>{
    const drive = google.drive({version: 'v3', auth});
    let downloadfilename = file.name;
    let downloadfilepath = savepath+'/'+file.folderName+'/'+file.name;
    let downloadfileid = file.id;
    let downloadmimetype = file.mimeType;
    let dest = fs.createWriteStream(downloadfilepath);
    await drive.files.get({
        fileId: downloadfileid,
        alt: 'media',
    }, {responseType: 'stream'}, async (err,res) => {
        try {
            await res.data.on('end', () => {
                console.log(downloadfilepath+' Done');
                if(downloadfilename==gosync){
                    drive.files.delete({
                        fileId: downloadfileid,
                    });
                    fs.unlink(downloadfilepath, (err) => {
                        if(err){throw err;}
                    });
                    fs.writeFile(uploadfilepath, '', (err)=>{
                        if(err){throw err;}
                    });
                }
            }).on('error', (err) => {
                console.log('Error during download', err);
            }).pipe(dest);
        }catch(err){
            console.log('err: wait a while and try once again ' + downloadfilename);
            sleep(ewaittimer).then(()=>{
                downloadFile(auth, file);
            });
        }
    });
}

const excludefiles=['dont-remove-me.md','remain-me-all-the-way.md'];
const gosync='syncsyncsync.txt';
const uploadfilepath='/var/www/hexo/upload.flg';
const ewaittimer=1000;