import readlinePromises from 'readline/promises';
import { existsSync, createWriteStream } from 'fs';
import { mkdir, writeFile, unlink } from 'fs/promises';
import { Readable } from 'stream';
import { finished } from 'stream/promises';

const getValidId = (str) => (str || '').replace(/( |\/|\\)/gm,'_');

const saveVariantsToDestination = async (inVal, fetchUrl, destination, destinationShort) => {
  const rootUrl = fetchUrl.replace(/((http)|(https)):\/\//, '').split('/')[0];
  const outVal = JSON.parse(JSON.stringify(inVal));
  await Promise.all(Object.keys(outVal.entries).map(async entryId => {
    const entryPath = `${destination}/${entryId}`
    if (!existsSync(entryPath)) {
      await mkdir(entryPath);
    }
    await Promise.all(outVal.entries[entryId].variants.map(async (variant, index) => {
      const variantPath = `${entryPath}/${variant.url.replace('/uploads/', '')}`;
      if (existsSync(variantPath)) {
        await unlink(variantPath);
      }
      const variantFile = await fetch(`http://${rootUrl}${variant.url}`);
      const variantStream = createWriteStream(variantPath, { flags: 'wx' });
      await finished(Readable.fromWeb(variantFile.body).pipe(variantStream));

      const thumbnailPath = `${entryPath}/${variant.thumbnailUrl.replace('/uploads/', '')}`;
      if (existsSync(thumbnailPath)) {
        await unlink(thumbnailPath);
      }
      const thumbnailFile = await fetch(`http://${rootUrl}${variant.thumbnailUrl}`);
      const thumbnailStream = createWriteStream(thumbnailPath, { flags: 'wx' });
      await finished(Readable.fromWeb(thumbnailFile.body).pipe(thumbnailStream));

      outVal.entries[entryId].variants[index].url = `/content/${destinationShort}/${entryId}/${variant.url.replace('/uploads/', '')}`;
      outVal.entries[entryId].variants[index].thumbnailUrl = `/content/${destinationShort}/${entryId}/${variant.thumbnailUrl.replace('/uploads/', '')}`;
    }));
  }));

  return outVal;
};

const mapper = (inVal) => {
  const { data } = inVal;
  const outVal = {};

  // handle list basic fields
  outVal.title = data.title;
  
  // handle list entries
  outVal.entries = {};
  data.entries.forEach(entry => {
    // give it an id
    const id = `${getValidId(entry.date)}_${getValidId(entry.title)}_${getValidId(entry.documentId)}`;

    // copy all values at first...
    outVal.entries[id] = {...entry};

    // ...then delete strapi fields (as there are more to copy than delete)
    delete outVal.entries[id].id;
    delete outVal.entries[id].documentId;
    delete outVal.entries[id].createdAt;
    delete outVal.entries[id].updatedAt;
    delete outVal.entries[id].publishedAt;
    delete outVal.entries[id].locale;

    // ...then handle variants
    outVal.entries[id].variants = entry.variants.map(variant => ({
      alternativeText: variant.alternativeText,
      caption: variant.caption,
      // the images will currently be mapped to strapi, to be handled with file grabber
      url: variant.url,
      thumbnailUrl: variant.formats['thumbnail'].url, // TBD: non-image assets
    }));

    // ...also post-process tags into an array
    outVal.entries[id].tags = (outVal.entries[id].tags || '').split(/,| |;/).filter(val => val !== '');
  });

  return outVal;
};

(async () => {
  const rl = readlinePromises.createInterface(process.stdin, process.stdout);
  let fetchUrl = '';
  try {
    fetchUrl = await rl.question('Enter the URL to fetch from: ');
  } catch (err) {
    console.error('There was an error: ', err);
  } finally {
    if (!fetchUrl) {
      console.log('Invalid URL. Quitting...');
      rl.close();
      return;
    } else if (!fetchUrl.includes('?')) {
      fetchUrl += '?populate[0]=entries&populate[1]=entries.variants&populate[2]=tags&populate[3]=tags.value'
    }
  }

  let destination = '';
  try {
    destination = await rl.question('Enter the directory to save the response\n(note: this should be a path relative to "sites";\n{your/input} will become sites/{your/input}):');
    destination = 'sites/' + destination;
  } catch (err) {
    console.error('There was an error: ', err);
  } finally {
    rl.close();
    if (!destination) {
      console.log('Invalid path. Quitting...');
      return;
    } else {
      if (!existsSync(destination)) {
        await mkdir(destination, { recursive: true });
      }
    }
  }

  let res = {};
  try {
    res = await (await fetch(fetchUrl, {
      method: 'GET',
      headers: {
        'Content-Type': 'application/json',
      },
    })).json();
  } catch (err) {
    console.error('There was an error: ', err);
  }

  console.log('Writing...');
  try {
    await writeFile(`${destination}/in.json`, JSON.stringify(res, null, 2));
    let list = mapper(res);
    list = await saveVariantsToDestination(list, fetchUrl, destination, destination.replace('sites/', '').split('/').slice(1).join('/'));
    await writeFile(`${destination}/out.json`, JSON.stringify(list, null, 2));
  } catch (err) {
    console.error('There was an error: ', err)
  }
})();