main.js

const axios = require('axios');
const { version } = require('./package.json');
const fs = require('fs');
const { Console } = require('console');
var v5 = require('uuidv5');
let Parser = require('rss-parser');
const FormData = require('form-data');
const imageDataURI = require('image-data-uri');
const { stringify } = require('querystring');
var request = require('request')
const Downloader = require('nodejs-file-downloader');
const YTDlpWrap = require('yt-dlp-wrap').default;
const { parse } = require('rss-to-json');
const { constants } = require('crypto');
const { extract } = require('@extractus/feed-extractor');
const milliday = 24*60*60*1000;
const rssLicences = ["","CC-BY-4.0", "CC-BY-SA-4.0", "CC-BY-ND-4.0", "CC-BY-NC-4.0", "CC-BY-NC-SA-4.0", "CC-BY-NC-ND-4.0", "CC-PDDC"];
async function register ({
  registerHook,
  registerSetting,
  settingsManager,
  storageManager,
  peertubeHelpers,
  getRouter,
  videoCategoryManager,
  videoLicenceManager,
  videoLanguageManager
}) {
  registerSetting({
    name: 'pi-key',
    label: 'Podcast Index provided API key for podping',
    type: 'input',
    descriptionHTML: 'Setting this value enables podping for the configurable legacy RSS feed',
    private: false
  })
  registerSetting({
    name: 'pi-proxy',
    label: 'PeerTube proxy instance for podpinging',
    type: 'input',
    descriptionHTML: 'Setting this value enables podping proxy for the configurable legacy RSS feed, ignored if API Key set',
    default: 'https://freediverse.com',
    private: false
  })

    registerSetting({
    name: 'rss-enable',
    default: true,
    label: 'Enable enhanced Podcasting 2.0 configuration',
    type: 'input-checkbox',
    descriptionHTML: 'This will enable enhances podcasting 2.0 namespace configuration via channel managemnt page',
    private: false
  })
  registerSetting({
    name: 'irc-enable',
    default: false,
    label: 'Enable IRC chat for channels',
    type: 'input-checkbox',
    descriptionHTML: 'This will enable IRC chat for every channel. Channels can customize the autogenerated room if they have a preferred room',
    private: false
  })
    registerSetting({
    name: 'debug-enable',
    default: false,
    label: 'Enable diagnostic log updates',
    type: 'input-checkbox',
    descriptionHTML: 'This will create more extensive logging of program state data both client and server side for finding and resolving errors ',
    private: false
  })
  let enableRss = await settingsManager.getSetting("rss-enable");
  let enableChat = await settingsManager.getSettings("irc-enable");
  let enableDebug = await settingsManager.getSetting("debug-enable");
  let piKey = await settingsManager.getSetting("pi-key");
  let piProxy = await settingsManager.getSetting("pi-proxy");
  var base = await peertubeHelpers.config.getWebserverUrl();
  var basePath = peertubeHelpers.plugin.getDataDirectoryPath();
  var serverConfig = await peertubeHelpers.config.getServerConfig();
  var plugins = serverConfig.plugin.registered;
  var hostName = serverConfig.instance.name;
  let hostDescription = serverConfig.instance.shortDescription
  let hostParts= base.split('//');
  let hostDomain = hostParts.pop();
  const ytDlpWrap = new YTDlpWrap('/var/www/peertube/storage/bin/yt-dlp');
  
  console.log("🚧🚧🚧🚧 Podcast2 plugin started");
  if (enableDebug) {
    console.log("🚧🚧 home url",base,hostName);
    console.log("🚧🚧 server settings loaded", hostName, base, serverConfig, enableRss,enableChat);
    console.log("🚧🚧 continued", piKey,serverConfig.plugin.registered);
  }
  //let Parser = require('rss-parser');
  let dirtyHack;
  let parser = new Parser();
  let podcast2;
  let hiveTube;
  let lightning
  for (var plugin of plugins){
    switch (plugin.npmName){
      case 'peertube-plugin-podcast2' : podcast2=true;
      break;
      case 'peertube-plugin-hive-tube' : hiveTube=true;
      break;
      case 'peertube-plugin-peerhub' : hiveTube=true;
      break;
      case 'peertube-plugin-lightning' : lightning=true;
      break;
    } 
  }
  registerHook({
    target: 'action:api.video.updated',
    handler: async ({ video, body }) => {
      if (enableDebug) {
        console.log("🚧🚧🚧🚧🚧🚧 updating video!!!!\n",video);
      }
      //if (!body.pluginData) return
      let channel = video.VideoChannel.Actor.preferredUsername;
      let state = video.state;
      let uuid = video.uuid;
      if (enableDebug){
        console.log("🚧🚧🚧🚧🚧🚧 updating video data \n",channel,state,uuid,video.id);
      }const seasonNode = body.pluginData['seasonnode'];
      const seasonName = body.pluginData['seasonname'];
      const episodeNode = body.pluginData['episodenode'];
      const episodeName = body.pluginData['episodename'];
      const chapters = body.pluginData['chapters'];
      const itemTxt = body.pluginData['itemtxt'];
      const sourceId = body.pluginData['sourceid'];
      //if (!value) return
      storageManager.storeData('seasonnode-' + video.id, seasonNode);
      storageManager.storeData('seasonname-' + video.id, seasonName);
      storageManager.storeData('episodenode-' + video.id, episodeNode);
      storageManager.storeData('episodename-' + video.id, episodeName);
      storageManager.storeData('chapters-' + video.id, chapters);
      storageManager.storeData('itemtxt-' + video.id, itemTxt);
      if (sourceId){
        console.log("🚧🚧 source id for video",sourceId);
        storageManager.storeData('sourceid-' + video.id, sourceId);
      } else {
        console.log("🚧🚧 source id for video not updating",sourceId, video.id);
      }
      /*
      if (chapters && chapters !=""){
        let chaptersData,chaptersApi
        try {
          chaptersData = await axios.get(chapters);
          chaptersApi = `${base}/plugins/podcast2/router/chapters?video=${video.id}`

        } catch (err){
          console.log("🚧🚧🚧🚧🚧🚧 update chapters", err);
        }
      }
      */
      if (enableDebug){
        console.log("🚧🚧🚧🚧🚧🚧 clearing cache data for channel", channel);
      }
      await storageManager.storeData("rsscached-" + channel.replace(/\./g, "-"), 0);
      pingPI(channel)
      return;
    }
  })
    registerHook({
    target: 'filter:api.video.get.result',
    handler: async (video) => {
      if (!video) return video
      if (!video.pluginData) video.pluginData = {};

      video.pluginData['itemtxt'] = await storageManager.getData('itemtxt' + '-' + video.id);
      video.pluginData['chapters'] = await storageManager.getData('chapters' + '-' + video.id);
      video.pluginData['seasonnode'] = await storageManager.getData('seasonnode' + '-' + video.id);
      video.pluginData['seasonname'] = await storageManager.getData('seasonname' + '-' + video.id);
      video.pluginData['episodenode'] = await storageManager.getData('episodenode' + '-' + video.id);
      video.pluginData['episodename'] = await storageManager.getData('episodename' + '-' + video.id);
      video.pluginData['sourceid'] = await storageManager.getData('sourceid' + '-' +video.id);
      return video;
    }
  })
    registerHook({
    target: 'filter:feed.podcast.channel.create-custom-tags.result',
    handler: async (result, params) => {
      const { videoChannel } = params
     // console.log("🚧🚧🚧🚧 initial channel values 🚧🚧🚧🚧",params,params.videoChannel.dataValues.Account,params.videoChannel.Account);
      var channel = params.videoChannel.dataValues.Actor.dataValues.preferredUsername;
      var name =    params.videoChannel.dataValues.name;
      var accountName = params.videoChannel.dataValues.Account.dataValues.name;
      if (enableDebug){
         console.log("🚧🚧🚧🚧 initial channel values 🚧🚧🚧🚧",channel,"🚧",name,"🚧",accountName);
      }
      let podreturn = [];
      let channelGuid;
      /*
      apiUrl = base + "/plugins/podcast2/router/getchannelguid?channel=" + channel;
      try {
        let guidData = await axios.get(apiUrl);
        if (guidData && guidData.data) {
          console.log("🚧🚧channel guid", guidData.data,apiUrl);
          channelGuid = guidData.data;
        }
      } catch (err) {
        console.log("🚧🚧 hard error getting channel guid", apiUrl,err);
      }
      /*
      if (channelGuid){
        podreturn.push({
          name: "podcast:guid",
          value: channelGuid,
        });
      }
      */
      let podData;
      try {
        podData = await storageManager.getData("pod-" + channel.replace(/\./g, "-"));
        if (enableDebug){
          console.log("🚧🚧 got poddata ", channel,podData);
        }
      } catch (err) {
        console.log("🚧🚧error getting pod data for ", channel);
      }
      let publisherBlock = {};
      let publisherUrl = `${base}/plugins/podcast2/router/publisher`;
      let publisherGuid = v5('url',publisherUrl);
      publisherBlock.name = "podcast:publisher";
      let remoteItemBlock = [{
        name: "podcast:remoteItem",
        attributes: {
          "medium": "publisher",
          "feedGuid": publisherGuid,
          "feedUrl": publisherUrl
        }
      }];
      podreturn.push({
        name: "podcast:publisher",
        value: remoteItemBlock
      })
      if (!hiveTube && (piKey || piProxy)){
        podreturn.push({
          name: "podcast:podping",
          attributes: {
            "usesPodping": "true"
          }
        })
      }
      if (!hiveTube){
        let podroll = await getChannelPodroll(accountName);
        if (enableDebug){
          console.log("🚧🚧podroll", podroll);
        }
      }
      let roll = [];

      if (podroll && podroll.length>0){
        for (var podrollGuid of podroll){
          if (podData && podData.feedguid != podrollGuid){
            roll.push({
              "name": "podcast:remoteItem",
              attributes: {"feedGuid": podrollGuid}
            })
          }
        }
        podreturn.push({
          name: "podcast:podroll",
          value: roll,
        });
      } 
      if (podData && podData.email && podData.email.indexOf("@")>0){
        let blocks =[];
        let newBlock = {};
        newBlock.name = "itunes:owner";
        let iname = {};
        iname.name = "itunes:name";
        iname.value = name;
        blocks.push(iname);
        let iemail={};
        iemail.name = "itunes:email";
        iemail.value =podData.email
        blocks.push(iemail);
        podreturn.push({
          name: "itunes:owner",
          value: blocks,
        });
      }
      if (podData && podData.text && podData.text[0] != "") {
        let ptext = {
          name: "podcast:txt",
          value: podData.text[0]
        }
        podreturn.push(ptext);
      }
      if (podData && podData.feedguid && podData.feedguid !=""){ 
        channelGuid= podData.feedguid;
      }
      if (channelGuid && channelGuid !='' && !hiveTube){
        let fguid = {
          name: "podcast:guid",
          value: channelGuid
        }
        podreturn.push(fguid);  
      }
      /*
      if (podData && podData.feedguid && podData.feedguid != "") {
        let feedguid={
          name: "podcast:feedGuid",
          attributes: {text: podData.feedguid}
        }
        podreturn.push(feedguid);
      }
      */
      if (!hiveTube && (podData && podData.category && podData.category != "")) {
        let category={
          name: "itunes:category",
          attributes: {text: podData.category}
        }
        podreturn.push(category);
      }
      if (!hiveTube && podData && podData.image && podData.image !="") {
        let image={
          name: "itunes:image",
          attributes: {href: podData.image},
        }
        podreturn.push(image);
      }
      if (podData && podData.licence && podData.licence.key){
        
        let licence = {
          name: "podcast:license",
          value: rssLicences[podData.licence.key]
        }
        podreturn.push(licence);
        let copyright = {
          name: "copyright",
          value: rssLicences[podData.licence.key]
        }
        //podreturn.push(copyright); 
      }
      if (!hiveTube && name){
        let author = {
          name: "itunes:author",
          value: name
        }
        podreturn.push(author);
      }
      if (!hiveTube){
        let language = {
          name:"language",
          value: "en"
        }
        podreturn.push(language);
      }
      if (result){
        return result.concat(podreturn);
      } else {
        console.log("🚧🚧 weird error where result is undefined or false",podreturn,result);
      }
      if (enableDebug){
        console.log("🚧🚧 custom values for channel",podreturn);
      }
    }
  })
  registerHook({
    target: 'filter:feed.podcast.video.create-custom-tags.result',
    handler: async (result, params) => {      const { video, liveItem } = params
      //console.log("🚧🚧🚧🚧 initial video values 🚧🚧🚧🚧",result,params);
      if (liveItem) {
      }
      var videoUuid = params.video.dataValues.uuid;
      //var videoJSON = await peertubeHelpers.videos.loadByIdOrUUID(videoUuid)
      let customObjects = [];
      let captionApi = base + "/api/v1/videos/" + videoUuid + "/captions";
      let captionResult;
      let rssData =[];
      try {
        captionResult = await axios.get(captionApi);
      } catch (err) {
        console.log("🚧🚧failed requesting transcript data", captionApi,err);
      }
      let captionPath, captionLanguage, captionItem;
      //if (captionResult && captionResult.data && captionResult.data.total > 0) {
      //console.log("🚧🚧\ncaption result", captionResult.data);
      if (captionResult && captionResult.data) {
        for (var captionEntry in captionResult.data.data) {
          captionPath = base + captionEntry.captionPath
          if (captionEntry.language) {
            captionLanguage = captionEntry.language.id;
          }
          if (captionPath.indexOf("vtt") > 1) {
            type = "text/vtt"
          } else {
            type = "text/plain"
            //fixed = fixed + "\n" + spacer + `<podcast:transcript url="` + captionPath + `" language="` + captionLanguage + `" type="text/plain" rel="captions"/>`;
          }
          captionItem = {
            name: "podcast:transcript",
            attributes: {
              "uri": captionPath,
              "language": captionLanguage,
              "type": type,
              "rel": "captions"
            }
          };
          customObjects.push(captionItem);
        }
      }
      var apiCall = base + "/api/v1/videos/" + videoUuid;
      let videoData;
      try {
        videoData = await axios.get(apiCall);
      } catch (err){
        console.log("🚧🚧failed to pull information for provided video id", apiCall,err);
      }
      if (videoData && videoData.data) {
        if (enableDebug){
          console.log("🚧🚧  video data found");
        }
        let embedPath = base+videoData.data.embedPath;
        let duration = videoData.data.duration;
        let customData = videoData.data.pluginData;
        let filename,videoFilename;
        let smallest = 999999999;
        let largest = 1;
        if (enableDebug){
          //console.log("🚧🚧  streaming playlists",videoData.data.streamingPlaylists);
        }
        if (embedPath){
          let embedEnclosure = {
            name: "podcast:embedEnclosure",
            type: "video/peertube",
            length: duration,
            title: "PeerTube",
            url: embedPath,
          }
          rssData.push(embedEnclosure)
        }
        if (!hiveTube && duration){
          let itemDuration = {
            name: "itunes:duration",
            value: await duration.toString()
          }
          customObjects.push(itemDuration);
        }
        if (videoData.data.streamingPlaylists[0]){
          let videoFiles = videoData.data.streamingPlaylists[0].files;
          if (videoFiles) {
            for (var fileOption of videoFiles) {
              //console.log("[pod] file options",fileOption);
              if (fileOption.size < smallest) {
                smallest = fileOption.size;
                filename = fileOption.fileUrl
              }
              if (fileOption.size > largest) {
                largest = fileOption.size;
                videoFilename = fileOption.fileUrl
              }
            }
          }
        } else {
          if (enableDebug){
            console.log("[pod] video streaming file data found",videoData.data);
          }
        }
        var enclosure,videoEnclosure;
        var enclosureType;
        if (enableDebug){
          console.log("\n🚧🚧\n\n\nsmallest file",filename,smallest,videoFilename,largest);
        }
        if (filename) {
          enclosureType = "video/mp4";
          if (filename.includes("-0-")){
            enclosureType="audio/mp4";
          }
          enclosure = {
            name: "audio",
            url: filename,
            type: enclosureType,
            length: duration
          }
        } 
        if (videoFilename) {
          enclosureType = "video/mp4";
          videoEnclosure = {
            name: "video",
            url: videoFilename,
            type: enclosureType,
            length: duration
          }
        } 
        if (enclosure) {
          //customObjects.push(enclosure);
          rssData.push(enclosure)
        }
        if (videoEnclosure) {
          //customObjects.push(videoEnclosure);
          rssData.push(videoEnclosure)
        }
        if (enableDebug){
          console.log("🚧🚧\nplugin data", customData);
        }
        if (customData && customData.seasonnode){
          let seasonItem = {
            name: "podcast:season",
            value: await customData.seasonnode.toString()
          };
          if (customData.seasonname){
            seasonItem.attributes={
              "name": customData.seasonname
            }
          }
          customObjects.push(seasonItem);
          let itunesSeason = {
            name: "itunes:season",
            value: await customData.seasonnode.toString()
          }
          customObjects.push(itunesSeason);
        }
        if (customData && customData.episodenode){
          let episodeItem = {
            name: "podcast:episode",
            value: await customData.episodenode.toString()
          };
          if (customData.episodename){
            episodeItem.attributes={
              "display": customData.episodename
            }
          }
          customObjects.push(episodeItem);
          let itunesEpisode = {
            name: "itunes:episode",
            value: await customData.episodenode.toString()
          }
          customObjects.push(itunesEpisode)
        }
        let chaptersItem,chaptersApi,chaptersData;
        if (!hiveTube && customData && customData.chapters){
          chaptersItem = {
            name: "podcast:chapters",
            attributes: {
              "url": customData.chapters,
              type: "application/json+chapters"
            }
          };
          customObjects.push(chaptersItem);
        } else if (!hiveTube) {
          chaptersApi = `${base}/plugins/podcast2/router/chapters?video=${videoUuid}`
          try {
            let chaptersData = await axios.get(chaptersApi);
            //console.log("🚧🚧 chapters ", chaptersData.data, Array.isArray(chaptersData.data.chapters),chaptersData.data.chapters.length);
            if (chaptersData && chaptersData.data && chaptersData.data.chapters && Array.isArray(chaptersData.data.chapters) && chaptersData.data.chapters.length>0){
              chaptersItem = {
                name: "podcast:chapters",
                attributes: {
                  "url": chaptersApi,
                  type: "application/json+chapters"
                }
              }
              customObjects.push(chaptersItem);          
            }
          } catch (err) {
            console.log("🚧🚧 hard error getting chapters ", chaptersApi,err);
          }
        }
        //console.log("🚧🚧 chaptersitem ", chaptersItem);

        if (customData && customData.itemtxt){
         // let txtValue=[].push(customData.itemtxt);
          let txtItem = {
            name: "podcast:txt",
            value: customData.itemtxt
          }
          customObjects.push(txtItem);
        }
        if (customData && customData.sourceid){
          let sourceEnclosure = {
            name: "podcast:ytEnclosure",
            type: "video/youtube",
            length: duration,
            title: "YouTube",
            url: `https://www.youtube.com/embed/${customData.sourceid}`
          }
          rssData.push(sourceEnclosure)
        }
      }
      if (enableDebug){
        console.log("🚧🚧 custom objects to add to video",customObjects);
        console.log("🚧🚧 custom objects to store for rss",rssData);
      }
      await storageManager.storeData('rssvideodata-'+videoUuid,rssData);
      if (result){
        return result.concat(customObjects);
      } else {
        console.log("🚧🚧 weird error where result is undefined or false",customObjects,result);
      }
    }
  })

  registerHook({
    target: 'action:live.video.state.updated',
    handler: async (video) => {
      //if (video.privacy !== VideoPrivacy.PUBLIC) {
      //  return
      //}
      if (enableDebug){
        console.log ("🚧🚧🚧🚧 video state updated",video.video.VideoChannel.Actor.preferredUsername, video.video.state )
      }
      let channel = video.video.VideoChannel.Actor.preferredUsername;
      let state = video.video.state;
      let uuid = video.video.uuid;
      //await pingPI(video.chann)
      if (enableDebug){
        if (video && video.video){
          console.log("⚡️⚡️ live video updated",video.video.uuid,video.video.state);
        } else {
          console.log("⚡️⚡️ video.video missing from action",video.dataValues,video.DataModel,video.video);
          return;
        }
      }
      if (video.video.state !=1){
        if (enableDebug){
          console.log("⚡️⚡️ live stream ended",channel,state,uuid);
        }
        await storageManager.storeData("rsscached-" + channel.replace(/\./g, "-"), 0);
        await pingPI(channel,null,"liveEnd");
        return;
      } else {
        if (enableDebug){
          console.log("⚡️⚡️ live stream started?",channel,state,uuid);
        }
        await storageManager.storeData("rsscached-" + channel.replace(/\./g, "-"), 0);
        await pingPI(channel,null,"live");
      }
    }
  })
  
  registerHook({
    target: 'action:api.video.uploaded',
    handler: async (video) => {
      if (enableDebug){
        console.log ("🚧🚧🚧🚧 video uploaded",video.video.VideoChannel.Actor.preferredUsername, video.video.state )
      }
      let channel = video.video.VideoChannel.Actor.preferredUsername;
      let state = video.video.state;
      let uuid = video.video.uuid;
      await storageManager.storeData("rsscached-" + channel.replace(/\./g, "-"), 0);
      await pingPI(channel);
    }
  })

  registerHook({
    target: 'action:api.video.deleted',
    handler: async (video) => {

      console.log ("🚧🚧🚧🚧 video deleted");
      let channel = video.video.VideoChannel.Actor.preferredUsername;
      let state = video.video.state;
      let uuid = video.video.uuid;
      console.log("🚧🚧🚧🚧🚧🚧 clearing cache data for channel of livestream starting", channel,state,video.video.name,video.video.title);
      await storageManager.storeData("rsscached-" + channel.replace(/\./g, "-"), 0);
      pingPI(channel);
    }
  })

  registerHook({
    target: 'action:notifier.notification.created',
    handler: async (notification) => {
      if (!notification.notification.VideoImport){
        console.log("🚧🚧🚧🚧 not a video import");
        return;
      }
      try {
        let youtubeUrl = notification.notification.VideoImport.targetUrl;
        let peertubeUuid = notification.notification.VideoImport.Video.id;
        let youtubeUuid = youtubeUrl.split("/").pop();
        //synched url is different from manual import, fix added
        youtubeUuid = youtubeUrl.split("=").pop();
        console.log("🚧🚧🚧🚧  doing notification values",youtubeUrl,youtubeUuid,peertubeUuid);
        await storageManager.storeData('sourceid-' + peertubeUuid, youtubeUuid);
        
        /*
        let metadata = await ytDlpWrap.getVideoInfo(youtubeUrl);
        console.log("🚧🚧🚧🚧 yt dlp data ",metadata.automatic_captions.en );
        for (var extension of metadata.automatic_captions.en){
          if (extension.ext == 'vtt'){
            console.log("🚧🚧🚧🚧 hot hit",extension );
          }
        }
        */
      } catch (err) {
        console.log("🚧🚧🚧🚧 error doing notification import update",err,notification);
      }
    }
  })

  const router = getRouter();

  router.use('/publisher', async (req,res) =>{
    res.setHeader('content-type', 'application/rss+xml');
    if (enableDebug) {
      console.log("⚓⚓⚓⚓ publisher feed request",req.query);
    }
    let lastCached = await storageManager.getData("publisher-rss-cached");
    let refreshTime = Date.now()-lastCached
    if (enableDebug){
      console.log("🚧🚧 chached rss feed", lastCached,refreshTime,milliday,req.query.force);
    }
    if ((refreshTime < milliday)  && !req.query.force){
      let cache = await storageManager.getData("publisher-rss-cache");
      if (enableDebug){
        console.log("🚧🚧 returning chached publisher rss feed", lastCached,refreshTime,milliday);
      }
      return res.status(200).send(cache);
    }


    let videoList;
    let displayName = hostName;
    let description = hostDescription;
    let url = `${base}/plugins/podcast2/router/publisher`;
    let linkUrl = base;
    let atomLink = url;
    let imageUrl = "https://freediverse.com/lazy-static/avatars/a9e4fd2c-1895-49fb-9824-3886e89dc948.jpg"
    let rssCache;
    let rssFile;
    let timeDiff;
    let channelData
    let podData;
    if (enableDebug) {
      //console.log("⚓⚓⚓⚓ video list", videoList);
    }
    //check for cached channel rss
    //get channel data
    channelData = await getInstanceChannels();

    let publisherGuid = v5('url',url);
    // Start RSS generation
    let rss = `<rss xmlns:itunes="http://www.itunes.com/dtds/podcast-1.0.dtd" xmlns:podcast="https://github.com/Podcastindex-org/podcast-namespace/blob/main/docs/1.0.md" version="2.0">`
    let indent =4;
    rss = rss +"\n"+' '.repeat(indent)+`<channel>`;
    indent = indent+4;
    rss = rss + `\n`+' '.repeat(indent)+`<title>${hostName}</title>`;
    rss = rss + `\n`+' '.repeat(indent)+`<link>${url}</link>`;
    rss = rss + `\n`+' '.repeat(indent)+`<podcast:guid>${publisherGuid}</podcast:guid>`;
    if (description){
      rss = rss + `\n`+' '.repeat(indent)+`<description> ${description} </description>`;
    } else {
      rss = rss + `\n`+' '.repeat(indent)+`<description> indescribable </description>`;
    }
    rss = rss + `\n`+' '.repeat(indent)+`<podcast:medium>publisher</podcast:medium>`;
    rss = rss + `\n`+' '.repeat(indent)+`<generator>peertube-plugin-podcast2</generator>`;
    rss = rss + `\n`+' '.repeat(indent)+`<image>`;
    indent=indent+4
    rss = rss + `\n`+' '.repeat(indent)+`<url>${imageUrl}</url>`;
    rss = rss + `\n`+' '.repeat(indent)+`<title>${hostName}</title>`;
    rss = rss + `\n`+' '.repeat(indent)+`<link>${base}</link>`;
    rss = rss + `\n`+' '.repeat(indent)+`<width>1500</width>`;
    rss = rss + `\n`+' '.repeat(indent)+`<height>1500</height>`;
    indent=indent-3
    rss = rss + `\n`+' '.repeat(indent)+`</image>`;
    if (channelData){
      for (var channel of channelData){
        try {
          podData = await storageManager.getData("pod-" + channel.name.replace(/\./g, "-"));
        } catch (err) {
          console.log("🚧🚧hard error getting pod data for ", channel);
        }
        console.log("🚧🚧 pod data returned",podData);
        if (podData && podData.feedguid) {
          var podMedium = podData.medium;
          if (!podMedium){
            podMedium = `video`
          }
          var podUrl = `${base}/plugins/podcast2/router/podcast2?channel=${channel.name}`
          var podName = channel.displayName;
          rss = rss + `\n`+' '.repeat(indent)+`<podcast:remoteItem feedGuid="${podData.feedguid}" feedUrl="${podUrl}" medium="${podMedium}" title="${podName}" />`;
        } 
      }
    }

    indent=indent-4
    rss = rss + `\n`+' '.repeat(indent)+`</channel>`;
    rss = rss + `\n</rss>\n`;
    let lastCache=Date.now();
    await storageManager.storeData("publisher-rss-cached", lastCache);
    await storageManager.storeData("publisher-rss-cache", rss);
    console.log("🚧🚧\n\n\n\n updating cached publisher rss feed \n");
    return  res.status(200).send(rss);
  })
  router.use('/rss', async (req, res) => {
    if (enableDebug) {
      console.log("🚧🚧🚧🚧🚧🚧🚧🚧🚧🚧 podcast2 rss request 🚧🚧🚧🚧🚧🚧🚧🚧", req.query);
    }
    if (!enableRss) {
      console.log("🚧🚧🚧🚧🚧🚧🚧🚧🚧🚧RSS disabled");
      return res.status(403).send();
    }
    if (req.query.channel == undefined) {
      console.log("🚧🚧no channel requested", req.query);
      return res.status(404).send();
    }
    let podData
    let podApi = base + "/plugins/podcast2/router/getpoddata?channel=" + req.query.channel;
    try {
      podData = await axios.get(podApi);
    } catch {
      console.log("unable to load PODCAST data",req.query.channel,podApi);
    }
    if (podData) {
      console.log("🚧🚧\n\n\n\n pod data \n", podData.data);
      if (podData.data && podData.data.redirectEnabled){
        //return res.redirect(301, podData.data.redirectUrl);
        res.set('location', podData.data.redirectUrl);
        return res.status(301).send()
      }
    }
    let channel = req.query.channel
    let apiUrl = base + "/api/v1/video-channels/" + channel;
    let channelData;
    try {
      channelData = await axios.get(apiUrl);
    } catch {
      console.log("🚧🚧🚧🚧unable to load channel info", apiUrl);
      return res.status(400).send();  
    }
    let smallChannelAvatar, largeChannelAvatar, smallPersonAvatar, largePersonAvatar
    if (channelData && channelData.data && channelData.data.avatars && channelData.data.avatars[1]) {
      smallChannelAvatar = channelData.data.avatars[0].path;
      largeChannelAvatar = channelData.data.avatars[1].path;
    }
    if (channelData && channelData.data && channelData.data.ownerAccount && channelData.data.ownerAccount.avatars && channelData.data.ownerAccount.avatars[1]) {
      smallPersonAvatar = channelData.data.ownerAccount.avatars[0].path;
      largePersonAvatar = channelData.data.ownerAccount.avatars[1].path;
    }
    console.log("🚧🚧🚧🚧channel info", channelData.data);
    
    let rssUrl = base + "/feeds/podcast/videos.xml?videoChannelId=" + channelData.data.id;
    let rssData;
    try {
      rssData = await axios.get(rssUrl)
    } catch {
      console.log("🚧🚧unable to load rss feed for", channel, rssUrl);
      return res.status(400).send();
    }
    try{
    var rssJson = await extract(rssUrl, {normalization:false });
    } catch (err) {
      console.log("🚧🚧error loading rss", rssUrl,err);
    }
    console.log(JSON.stringify(rssJson, null, 3));
    return res.status(200).send(rssJson); 
  })
  router.use (`/chapters`, async (req,res) => {
    if (enableDebug) {
      console.log("🚧🚧 chapters request", req.query);
    }
    let videoId,chapters,chapterData,chapterApi;
    if (req.query.video){
      videoId = req.query.video      
    } else {
      console.log("🚧🚧 no video in request", req.query);
      return res.status(420).send("no video");
    }
    let customChapters = await storageManager.getData('chapters' + '-' + videoId);
    if (customChapters){
      try {
        chapterData = await axios.get(customChapters);
      } catch (err) {
        console.log("hard error getting custom chapters file",customChapters,err);
      }
      if (chapterData && chapterData.data)
      return(chapterData.data);
    }
    chapterApi = `${base}/api/v1/videos/${videoId}/chapters`
    try {
      chapterData = await axios.get(chapterApi);
    } catch (err) {
      console.log("🚧🚧 hard error getting chapters", chapterApi, err);
    }
    if (chapterData){
      chapters = chapterData.data
      if (chapters){
        for (var chapter of chapters.chapters){
          chapter.startTime=chapter.timecode;
          delete chapter.timecode;
        }
      }
      if (enableDebug){
        console.log("🚧🚧 chapters ", chapters);
      }
    } 
    return res.status(200).send(chapters);
  })
  /*
  router.use('/torrent', async (req,res) =>{
    if (enableDebug) {
      console.log("🚧🚧🚧🚧 torrent feed request",req.query);
    }
    if (!enableRss) {
      console.log("🚧🚧🚧🚧🚧🚧🚧🚧🚧🚧RSS disabled");
      return res.status(403).send();
    }
    let channel;
    if (req.query.channel == undefined) {
      console.log("🚧🚧no channel requested", req.query);
      return res.status(404).send();
    } else {
      channel = req.query.channel;
    }
    let podData
    let podApi = base + "/plugins/podcast2/router/getpoddata?channel=" + req.query.channel;
    try {
      podData = await axios.get(podApi);
    } catch {
      console.log("unable to load PODCAST data",req.query.channel,podApi);
    }
    let audio;
    if (podData) {
      console.log("🚧🚧\n\n\n\n pod data \n", podData.data);
      if (podData.data && podData.data.medium){
        if (podData.data.medium == 'audiobook' || podData.data.medium == 'music' || podData.data.medium == 'podcast'){
          audio=true;
        }
      }
    }
    let apiUrl = base + "/api/v1/video-channels/" + channel;
    let channelData;
    try {
      channelData = await axios.get(apiUrl);
    } catch {
      console.log("🚧🚧🚧🚧unable to load channel info", apiUrl);
      return res.status(400).send();
    }
    if (enableDebug) {
      console.log("🚧🚧🚧🚧 channel Data",channelData.data);
    }
    apiUrl = `${base}/api/v1/video-channels/${channel}/videos`;
    let videoData;
    try {
      videoData = await axios.get(apiUrl);
    } catch {
      console.log("🚧🚧🚧🚧unable to load video  info", apiUrl);
      return res.status(400).send();
    }
    if (enableDebug) {
      console.log("🚧🚧🚧🚧 video Data",videoData.data);
    }
    if (videoData && videoData.data ){
      videoList = videoData.data.data;
    } else {
      videoList = [];
    }
    if (enableDebug) {
      console.log("🚧🚧🚧🚧 video list",videoList);
    }
    let rss = `<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">`;
    let indent =4;
    rss = rss +"\n"+' '.repeat(indent)+`<channel>`;
    indent = indent+4;
    rss = rss + `\n`+' '.repeat(indent)+`<title>${channelData.data.displayName.replace(/\W+/g, " ")}</title>`;
    rss = rss + `\n`+' '.repeat(indent)+`<link>${channelData.data.url}</link>`;
    if (channelData.data.description){
      rss = rss + `\n`+' '.repeat(indent)+`<description> ${channelData.data.description.replace(/\W+/g, " ")} </description>`;
    } else {
      rss = rss + `\n`+' '.repeat(indent)+`<description> indescribable </description>`;
    }
    let atomLink = base + "/plugins/podcast2/router/torrent?channel=" + channel;
    rss = rss + `\n`+' '.repeat(indent)+`<atom:link href="${atomLink}" rel="self" type="application/rss+xml" />`;
    for (var video of videoList){
      rss = rss + `\n`+' '.repeat(indent)+`<item>`;
      indent = indent + 4;
      rss = rss + `\n`+' '.repeat(indent)+`<title>${video.name.replace(/\W+/g, " ")}</title>`;
      
      if (video.description){
        rss = rss + `\n`+' '.repeat(indent)+`<description>`;
        indent=indent+4;
        rss = rss + `\n`+' '.repeat(indent)+`${video.description.replace(/\W+/g, " ")}`;
        indent=indent-4;
        rss = rss + `\n`+' '.repeat(indent)+`</description>`;
      } else {
        rss = rss + `\n`+' '.repeat(indent)+`<description/>`;
      }
      
      let apiUrl = `${base}/api/v1/videos/${video.uuid}`;
      let videoSpecificData;
      let torrentUrl, fileSize, magnet, tracker, pubDate,rawDate;
      try {
        videoSpecificData = await axios.get(apiUrl);
      } catch (err) {
        console.log("🚧🚧🚧🚧unable to load video specific info", apiUrl,err);
        return res.status(400).send();
      }
      if (enableDebug) {
        let v;
        v = videoSpecificData.data;
        console.log("🚧🚧🚧🚧 video specific data",v,v.files,v.streamingPlaylists[0],v.streamingPlaylists[0].files);
      }
      
      torrentUrl = videoSpecificData.data.streamingPlaylists[0].files[0].torrentUrl;
      fileSize =   videoSpecificData.data.streamingPlaylists[0].files[0].size;
      magnet = videoSpecificData.data.streamingPlaylists[0].files[0].magnetUri;
      tracker = videoSpecificData.data.trackerUrls[0];
      console.log("🚧🚧🚧🚧 published", pubDate);
      let fileName = video.name;
      console.log("🚧🚧🚧🚧 found file name", fileName);
      rss = rss + `\n`+' '.repeat(indent)+`<enclosure type="application/x-bittorrent" url="${torrentUrl}" length="${fileSize}" />`;
      rss = rss + `\n`+' '.repeat(indent)+`<link>${torrentUrl}</link>`;
      rss = rss + `\n`+' '.repeat(indent)+`<guid>${torrentUrl}</guid>`;
      //rss = rss + `\n`+' '.repeat(indent)+`<media:content url="${torrentUrl}" fileSize="${fileSize}" />`;
      if (videoSpecificData.data.originallyPublishedAt){
        rawDate = videoSpecificData.data.originallyPublishedAt;
      } else {
        rawDate = videoSpecificData.data.publishedAt;
      }
        let newDate = new Date(rawDate);
      pubDate = newDate.toUTCString();

      console.log("🚧🚧🚧🚧 published", rawDate, "new format",newDate, "final format",pubDate);
      rss = rss + `\n`+' '.repeat(indent)+`<pubDate> ${pubDate} </pubDate>`;
      
      /*
      rss = rss + `\n`+' '.repeat(indent)+`<torrent>`;
      indent=indent +4;
      rss = rss + `\n`+' '.repeat(indent)+`<filename> ${fileName} </filename>`;
      rss = rss + `\n`+' '.repeat(indent)+`<contentlength> ${fileSize} </contentlength>`;
      rss = rss + `\n`+' '.repeat(indent)+`<magneturi> ${magnet} <magneturi>`;
      rss = rss + `\n`+' '.repeat(indent)+`<trackers>`;
      indent = indent +4;
      rss = rss + `\n`+' '.repeat(indent)+`<group order="ordered">`;
      indent = indent+4;
      rss = rss + `\n`+' '.repeat(indent)+`<tracker seeds="1" peers="1">`;
      indent = indent + 4;
      rss = rss + `\n`+' '.repeat(indent)+tracker;
      indent = indent - 4
      rss = rss + `\n`+' '.repeat(indent)+`</tracker>`;
      indent = indent -4;
      rss = rss + `\n`+' '.repeat(indent)+`</group>`;
      indent = indent - 4
      rss = rss + `\n`+' '.repeat(indent)+`</trackers>`;
      indent = indent -4;
      rss = rss + `\n`+' '.repeat(indent)+`</torrent>`;
      *
      indent = indent -4;
      
      rss = rss + `\n`+' '.repeat(indent)+`</item>`;
    }
    indent = indent-4;
    rss = rss + `\n`+' '.repeat(indent)+`</channel>`;
    rss = rss + `\n</rss>\n`;
    res.setHeader('content-type', 'application/rss+xml');
    return  res.status(200).send(rss);
  })
  */
  router.use('/podcast2', async (req, res) => {
    if (enableDebug) {
      console.log("🚧🚧🚧🚧🚧🚧🚧🚧🚧🚧 podcast2 request 🚧🚧🚧🚧🚧🚧🚧🚧", req.query);
    }
    if (!enableRss) {
      console.log("🚧🚧🚧🚧🚧🚧🚧🚧🚧🚧RSS disabled");
      return res.status(403).send();
    }
    if (req.query.channel == undefined) {
      console.log("🚧🚧no channel requested", req.query);
      return res.status(404).send();
    }
    let channel = req.query.channel
    //console.log("🚧🚧 response",res);
    //application/rss+xml
    //return;
    res.setHeader('content-type', 'application/rss+xml');
    let lastCached = await storageManager.getData("rsscached-" + channel.replace(/\./g, "-"));
    let refreshTime = Date.now()-lastCached
    console.log("🚧🚧 chached rss feed", lastCached,refreshTime,milliday,req.query.force);
    if ((refreshTime < milliday)  && !req.query.force){
      let cache = await storageManager.getData("rsscache-" + channel.replace(/\./g, "-"));
        console.log("🚧🚧 returning chached rss feed", lastCached,refreshTime,milliday);
      return res.status(200).send(cache);
    }
    let extendedRssData;
    let forceVideo,forceAudio;
    if (req.query.video){
      forceVideo=true;
    }
    if (req.query.audio){
      forceAudio = true;
    }
    let podData;
    let podApi = base + "/plugins/podcast2/router/getpoddata?channel=" + req.query.channel;
    try {
      podData = await axios.get(podApi);
    } catch {
      console.log("unable to load PODCAST data",req.query.channel,podApi);
    }
    if (podData) {
      if (enableDebug){
        console.log("🚧🚧\n\n\n\n pod data \n", podData.data);
      }
      if (podData.data && podData.data.redirectEnabled){
        //return res.redirect(301, podData.data.redirectUrl);
        res.set('location', podData.data.redirectUrl);
        return res.status(301).send()
      }
      let med;
      if (podData.data){
        med = podData.data.medium;
      }
      if (med == "audiobook" || med == "podcast" || med == "music"){
        forceAudio=true;
      }
      if (req.query.video){
        forceVideo=true;
      }
      if (req.query.audio){
        forceAudio = true;
      }
      //hack for now 
      if (!forceAudio){
        forceVideo = true;
      }
    }
   
    let apiUrl = base + "/api/v1/video-channels/" + channel;
    let channelData;
    try {
      channelData = await axios.get(apiUrl);
    } catch {
      console.log("🚧🚧🚧🚧unable to load channel info", apiUrl);
      return res.status(400).send();
    }
    let smallChannelAvatar, largeChannelAvatar, smallPersonAvatar, largePersonAvatar
    if (channelData && channelData.data && channelData.data.avatars && channelData.data.avatars[1]) {
      smallChannelAvatar = channelData.data.avatars[0].path;
      largeChannelAvatar = channelData.data.avatars[1].path;
    }
    if (channelData && channelData.data && channelData.data.ownerAccount && channelData.data.ownerAccount.avatars && channelData.data.ownerAccount.avatars[1]) {
      smallPersonAvatar = channelData.data.ownerAccount.avatars[0].path;
      largePersonAvatar = channelData.data.ownerAccount.avatars[1].path;
    }
    if (enableDebug){
      console.log("🚧🚧🚧🚧channel avatar info", channelData.data.ownerAccount.avatars);
    }
    let rssUrl = base + "/feeds/podcast/videos.xml?videoChannelId=" + channelData.data.id;
    let rssData;
    try {
      rssData = await axios.get(rssUrl)
    } catch {
      console.log("🚧🚧unable to load rss feed for", channel, rssUrl);
      return res.status(400).send();
    }
    //console.log("🚧🚧loaded rss feed from", rssUrl);
    let channelGuid;
    if (podData && podData.feedguid && podData.feedguid !=""){
      channelGuid = podData.feedguid
      if (enableDebug){
        console.log("🚧🚧channel guid from podData", channelGuid);
      } 
        /*} else {
      
      apiUrl = base + "/plugins/podcast2/router/getchannelguid?channel=" + channel;
      try {
        let guidData = await axios.get(apiUrl);
        if (guidData && guidData.data) {
          console.log("🚧🚧channel guid from podcast2", guidData.data);
          channelGuid = guidData.data;
        }
      } catch {
        console.log("🚧🚧unable to load channel guid from podcast2", apiUrl);
      }
      */
    }
    // 
    if (!channelGuid && lightning){
      apiUrl = base + "/plugins/lighting/router/getchannelguid?channel=" + channel;
      try {
        let guidData = await axios.get(apiUrl);
        if (guidData && guidData.data) {
          channelGuid = guidData.data;
        }
      } catch {
        console.log("🚧🚧unable to load channel guid from lightning", apiUrl);
      }
    }
    //TODO figure out how to get info for livechat plugin as well
    let duration = 69;
    let counter = 0;
    let fixed = "";
    let spacer = "";
    let rss = rssData.data;
    let lines = rss.split('\n');
      //console.log("🚧🚧\n\n\n\n starting linbe loop \n", lines.length,lines[33]);
    //for (const line of lines) {
    let totalSize = lines.length;
    while (counter<totalSize){
      let line = lines[counter];
      //console.log(`🚧line${counter}:`,line)
      counter++;
      spacer = line.split("<")[0];
      if (line.includes("Toraifōsu") && podData && podData.data) {

       // if (podData.data.text  && podData.data.text[0] != "") {
       //   line = line + `\n${spacer}<podcast:txt>${podData.data.text[0]}</podcast:txt>`;
       // }
       // if (podData.data.feedguid) {
       //   line = line + `\n${spacer}<podcast:guid>${podData.data.feedguid}</podcast:guid>`;
      //  }
      //  if (podData.data.email){
          //line = line + `\n${spacer}<itunes:owner>`;
          //line = line + `\n${spacer}  <itunes:name>${channelData.data.displayName}</itunes:name>`;
          //line = line + `\n${spacer}  <itunes:email>${podData.data.email}</itunes:email>`;
          //line = line + `\n${spacer}</itunes:owner>`;
          //line = line + `\n${spacer}<language>en</language>`;
          //line = line + `\n${spacer}<itunes:category text="News"/>`;
          //line = line + `\n${spacer}<itunes:image href="https://noagendaassets.com/enc/1686340519.979_pcifeedimage.png"/>`;
       // }
      }
      if (line.includes("<atom:link")) {
        line = `${spacer}<atom:link href="https://${req.get('host')}${req.originalUrl}" rel="self" type="application/rss+xml" />`;
        //line = line + `\n${spacer}<itunes:author>${channelData.data.displayName}</itunes:author>`;
      }
      if (line.includes("itunes:explicit")){
        line = line.replace("no","false");
        line = line.replace("yes","true");
      }
      var customData = {};
      if (line.includes('<guid')) {
        let temp1 = line.split(">")

        let shortUuid = line.split(">")[1].split("<")[0].split("/")[4]
        if (!shortUuid){
          shortUuid = temp1[1].split("_")[0];
        }
        //console.log("🚧🚧🚧🚧 trying to get guid from line for item", temp1, shortUuid,line);
        try {
          var videoData = await axios.get(base + "/api/v1/videos/" + shortUuid);
          if (videoData && videoData.data) {
            customData = videoData.data.pluginData;
          }
        } catch (err) {
          console.log("🚧🚧🚧🚧hard error trying to get video data for RSS feed", err);
        }
        if (enableDebug) {
          //console.log("🚧🚧🚧🚧item plugin data", shortUuid, customData);
        }

      }
      if (line.includes("<podcast:socialInteract"))
        uuid = await getUUID(line);
      if (line.includes("<enclosure") > 0) {
        var spot = line.indexOf("hls/");
        //var uuid = line.substring(spot+4,  spot+40);
        //console.log("🚧🚧🚧🚧 enclosure",line,uuid);
        //let test = await getUUID(line);
        //uuid = test;
        if (await isUUID(uuid)) {
          //console.log("🚧🚧🚧🚧enclosure",spot, "cut",">"+uuid+"<");
          try {
            var extended = await storageManager.getData('rssvideodata-'+uuid);
            if (enableDebug){
              console.log("Extended",extended);
            }
            for (file of extended){
              if (file && file.length){
                duration = file.length;
              }
              //console.log("🚧🚧🚧🚧first pass",file);
              if (file.name == 'audio' && forceAudio){
                line = `\n${spacer}<enclosure url="${file.url}" type="${file.type}" length="${file.length}"/>`
              } else if (file.name == 'video' && forceVideo) {
                line = `\n${spacer}<enclosure url="${file.url}" type="${file.type}" length="${file.length}"/>`
              } 
            }  
            for (file of extended){
              //console.log("🚧🚧🚧🚧second pass",file);
              if (file.name != 'audio' && file.name !='video'){
                line = line + `\n${spacer}<podcast:alternateEnclosure type="${file.type}" length="${file.length}" title="${file.title}">`
                line = line + `\n${spacer}  <podcast:source uri="${file.url}"/>`
                line = line + `\n${spacer}</podcast:alternateEnclosure>`
              }
            }
          } catch (err){
            console.log("🚧🚧🚧🚧 failed to get uuid from enclosure",spot, "cut",">"+uuid+"<",line,err);
          }
        } else {
          console.log("🚧🚧🚧🚧 failed to get uuid :(",uuid,line);
        }
      }
      if (line.includes(`title="HLS"`) && !line.includes(`length="`)) {
        //console.log("fixing length");
        line = line.replace(`title="HLS"`, `title="HLS" length ="${duration}"`);
      }
      if (largeChannelAvatar) {
        line = line.replace(smallChannelAvatar, largeChannelAvatar);
      }
      if (largePersonAvatar) {
        line = line.replace(smallPersonAvatar, largePersonAvatar);
      }
      if (podData && podData.data && podData.data.medium) {
        line = line.replace(`<podcast:medium>video</podcast:medium>`, `<podcast:medium>${podData.data.medium}</podcast:medium>`);
        if (podData.data.medium == 'audiobook' && line.indexOf("podcast:medium>audiobook")>0){
          line = line + `\n${spacer}<itunes:type>serial</itunes:type>`;
        }
      }
      if (line.indexOf("bitrate")>1){
        let parts = line.split('"');
        let intfix,intFixLine;
        for (var part of parts){
          if (part.indexOf(".")>1){
            intfix=part.split(".")[0];
            part=intfix;
          }
          intFixLine=intFixLine+part
        }
        line=intFixLine
      }
      if (counter > 1) {
        fixed = fixed + '\n' + line;
      } else {
        fixed = line;
      }
    }
    res.setHeader('content-type', 'application/rss+xml');
    //console.log("🚧🚧\n\n\n\n ending line loop \n",fixed.length);
    let lastCache=Date.now();
    await storageManager.storeData("rsscached-" + channel.replace(/\./g, "-"), lastCache);
    await storageManager.storeData("rsscache-" + channel.replace(/\./g, "-"), fixed);
    if (enableDebug){
      console.log("🚧🚧\n\n\n\n updating cached rss feed \n",fixed.length,channel);
    }
    return  res.status(200).send(fixed);
    
  })
  router.use('/dirtyhack', async (req, res) => {
    console.log("🚧🚧🚧🚧 dirty hack",req.query,req.body);
    /*
    if (req.query.cp){
      console.log("🚧🚧🚧🚧 clearing patronage paid days");
      let subscriptions = await storageManager.getData('subscriptions');
      let list = [];
      if (subscriptions){
        for (var sub of subscriptions){
          sub.paiddays=0;
        }
        storageManager.storeData("subscriptions", subscriptions);
        return res.status(200).send(subscriptions);
      }
    }
    */
    let feed;
    if (req.query.avatar){
      let result = updateChannelAvatar(req.query.avatar,'15',req.body.bear);
    }
    if (req.query.youtube){
      let metadata = await ytDlpWrap.getVideoInfo(req.query.youtube);
      console.log(metadata.title);
      console.log("🚧🚧🚧🚧 dirty hack::",metadata);
      return res.status(200).send(metadata);
      
    }
    //doSubscriptions();
    return res.status(200).send(dirtyHack);
  });
 /*
  router.use('/getfeedid', async (req, res) => {
    if (enableDebug) {
      console.log("🚧🚧getting feed id", req.query);
    }
    let channel = req.query.channel;
    if (!channel) {
      return res.status(420).send("no channel in feed id request");
    }
    let feed;
    let parts = channel.split('@');
    if (parts.length > 1) {
      if (enableDebug) {
        console.log("🚧🚧 remote request", parts);
      }
      let feedApi = "https://" + parts[1] + "/plugins/podcast2/router/getfeedid?channel=" + parts[0];
      try {
        feed = await axios.get(feedApi);
      } catch {
        console.log("🚧🚧hard error getting feed id for ", channel, "from", parts[1], feedApi);
      }
      if (feed && feed.data) {
        if (enableDebug) {
          console.log("🚧🚧 remote got feed", feed.data);
        }
        return res.status(200).send(feed.data.toString());
      }
      return res.status(420).send("remote channel returned no feed id");
    }
    if (channel) {
      if (enableDebug) {
        console.log("🚧🚧getting feed id locally", channel);
      }
      try {
        feed = await storageManager.getData("podcast" + "-" + channel)
      } catch (err) {
        console.log("🚧🚧error getting feedid", channel);
      }
    }
    if (enableDebug) {
      console.log(`🚧🚧 returning feed ID ${feed} for ${channel}`);
    }
    //console.log("🚧🚧 feed", feed);
    if (feed) {
      return res.status(200).send(feed.toString());
    } else {
      return res.status(400).send("no feed id found for requested channel");
    }

  })
  router.use('/setfeedid', async (req, res) => {
    if (enableDebug) {
      console.log("🚧🚧setting feed id", req.query);
    }
    let channel = req.query.channel;
    let feedID = req.query.feedid;
    if (channel) {
      try {
        await storageManager.storeData("podcast" + "-" + channel, feedID);
        return res.status(200).send();
      } catch (err) {
        console.log("🚧🚧 error storing feedid", channel, feedID);
        return res.status(400).send();
      }
    }
  })
  
  router.use('/getitemid', async (req, res) => {
    if (enableDebug) {
      console.log("🚧🚧getting item id", req.query);
    }
    let uuid = req.query.uuid;
    let item;
    if (uuid) {
      try {
        item = await storageManager.getData("podcast" + "-" + uuid);
      } catch (err) {
        console.log("🚧🚧 error getting stored itemid", uuid);
      }
    }
    if (item) {
      return res.status(200).send(item.toString());
    } else {
      var apiCall = base + "/api/v1/videos/" + uuid;
      let videoData;
      try {
        videoData = await axios.get(apiCall);
      } catch {
        console.log("🚧🚧failed to pull information for provided video id", apiCall);
      }
      if (videoData) {
        let videoHost = videoData.data.channel.host
        if ("https://" + videoHost != base) {
          let hostApi = "https://" + videoHost + "/plugins/podcast2/router/getitemid?uuid=" + uuid;
          let hostItemId;
          try {
            hostItemId = await axios.get(hostApi);
          } catch {
            console.log("🚧🚧failed to pull item ID from video host", hostApi);
          }
          if (hostItemId) {
            try {
              await storageManager.storeData("podcast" + "-" + uuid, hostItemId);
            } catch {
              console.log("🚧🚧failed to store item ID from host", uuid, hostItemId);
            }
            return res.status(200).send(hostItemId.data.toString());
          } else {
            console.log("🚧🚧 No id provided by hosting instance");
          }
        }
        let channel = videoData.data.channel.name;
        let feedApi = base + "/plugins/podcast2/router/getfeedid?channel=" + channel;
        try {
          feedId = await axios.get(feedApi);
        } catch {
          console.log("🚧🚧 error when tring to get feed id ", feedApi);
          return res.status(404).send();
        }

      }
      console.log("🚧🚧no videodata available", apiCall);
      return res.status(400).send();
    }
  })
  router.use('/setitemid', async (req, res) => {
    if (enableDebug) {
      console.log("🚧🚧setting item id", req.query.uuid);
    }
    let uuid = req.query.uuid;
    let itemID = req.query.itemid;
    if (uuid) {
      try {
        await storageManager.storeData("podcast" + "-" + uuid, itemID);
        return res.sendStatus(200);
      } catch (err) {
        console.log("🚧🚧error setting item id", uuid, itemID);
        return res.sendStatus(400).send();
      }
    }
  })
  
  router.use('/getchannelguid', async (req, res) => {
    if (enableDebug) {
      console.log("🚧🚧getting channel guid", req.query);
    }
    let host,channelOnly;
    let channel = req.query.channel;
    let parts = channel.split("@");
    if (parts.length>1){
      host = parts[1];
      channelOnly = parts[0];
    }
    let channelGuid;
    if (enableDebug) {
      console.log("🚧🚧 channel guid info", channel,host,channelOnly,channelGuid,parts);
    }    
    if (channel) {
      try {
        channelGuid = await storageManager.getData("channelguid" + "-" + channel.replace(/\./g, "-"))
          if (enableDebug) {
            console.log("🚧🚧channel guid from storage", channelGuid);
          }
      } catch (err) {
        console.log("🚧🚧 error getting channel guid", channel);
        return res.status(400).send();
      }
      /*
      if (!channelGuid){
        try {
          channelGuid = await storageManager.getData("podcast" + "-" + channel)
          if (enableDebug) {
            console.log("🚧🚧channel guid from lightning storage", channelGuid);
          }
        } catch (err) {
          console.log("🚧⚡️🚧⚡️🚧 error getting lighting feedid", channel);
        }
      }
      
    }
    if (!channelGuid &&  host && host !=hostDomain){
      apiUrl = `https://${host}/plugins/podcast2/router/getchannelguid?channel=${channel}`;
      try {
        console.log("🚧🚧 stuff",base,host,apiUrl);
        let guidData = await axios.get(apiUrl);
        if (guidData && guidData.data) {
          //console.log("🚧🚧channel guid", guidData.data);
          channelGuid = guidData.data;
          if (enableDebug) {
            console.log("🚧🚧channel guid from remote",host, channelGuid);
          }
        }
      } catch {
        console.log("🚧🚧unable to load channel guid", apiUrl);
      }
      if (!channelGuid){
        let feedApi = `https://${host}/plugins/lightning/router/getchannelguid?channel=${channel}`;
        let guidData;
        try {
          guidData = await axios.get(feedApi);
        } catch {
          console.log("🚧⚡️🚧⚡️🚧 hard error getting lighting feed id for ", channel, "from", host, feedApi);
        }
        if (guidData && guidData.data) {
          //console.log("⚡️⚡️ returning", feed.data, "for", channel,feed.data.toString());
          channelGuid = guidData.data;
          if (enableDebug) {
            console.log("🚧🚧channel guid from remote lighting", channelGuid);
          }
        }
      }
    }
    let rssUrl;
    if (channelGuid) {
      console.log("🚧🚧 returning channel guid",channelGuid);
      return res.status(200).send(channelGuid);
    } else {
      //TODO properly create guid
      //let guidResolverUrl = "https://guid.peertube.support/"
      if (enableDebug) {
        console.log("🚧🚧 no channel guid found, creating one");
      }  
      let rssUrl;
      if (channelOnly){
        rssUrl= await getRss(channelOnly);
      } else {
        rssUrl = await getRss(channel);
      }
      if (enableDebug) {
        console.log("🚧🚧creating podcast index from", rssUrl,channel,channelOnly);
      }
      if (rssUrl){
        try {
          channelGuid = await v5('url',rssUrl);
        } catch {
          console.log("🚧🚧HARD FAIL getting new guid for channel", rssUrl,channel,channelOnly,channelGuid);
        }
      }
      if (enableDebug) {
         console.log("🚧🚧channel guid generated", channelGuid,rssUrl);
      }
      if (channelGuid) {
        try {
          await storageManager.storeData("channelguid" + "-" + channel.replace(/\./g, "-"), channelGuid);
        } catch {
          console.log("🚧🚧failed to store channel guid", channel, channelGuid);
        }
        let setFeedApi = `https://${host}/plugins/lightning/router/setfeedid?channel=${channel}&feedid=${channelGuid}`;
        try {
          feed = await axios.get(feedApi);
        } catch {
          console.log(`🚧⚡️🚧⚡️🚧 hard error setting lightning feed id for ${channel} from ${host}`);
        }
        console.log("🚧🚧 returning channel guid",channelGuid);      
        return res.status(200).send(channelGuid);
      } else {
        console.log("🚧🚧 error attempting to generate channel guiid",channel);
        return res.status(400).send();
      }
    }
  })
  */
  router.use('/getpoddata', async (req, res) => {
    
    if (enableDebug) {
      console.log("🚧🚧getting pod data", req.query);
    }
    let channel = req.query.channel;
    if (!channel) {
      console.log("🚧🚧 no channel in query", channel, req.query);
      return res.status(400).send("🚧🚧 no channel value in request " + req.query);
    }
    let podData;
    try {
      podData = await storageManager.getData("pod-" + channel.replace(/\./g, "-"));
    } catch (err) {
      console.log("🚧🚧hard error getting pod data for ", channel);
      //return res.status(404).send("🚧🚧 no podcast data for " + req.query.channel + err);
    }
    if (!podData){
      podData={"channel": channel};
    }
    if (podData) {
      if (!podData.feedguid){
        console.log("🚧🚧 no pod data found, generating guid",channel,podData);
        let rssUrl = `${base}/plugins/podcast2/router/podcast2?channel=${channel}`
        try {
          podData.feedguid = v5('url',rssUrl);
        } catch {
          console.log("🚧🚧HARD FAIL getting new guid for channel", rssUrl,channel);
        }
      }
      console.log("🚧🚧 storing new guid",channel,podData.feedguid);
      await storageManager.storeData("pod-" + channel.replace(/\./g, "-"), podData);
      return res.status(200).send(podData);
    } else {
      if (enableDebug) {
        console.log("🚧🚧 no pod data in database", req.query);
      }
      //return res.status(404).send("🚧🚧 no pod data found for " + channel);
    }
    let parts = channel.split('@');
    let remotePodData;
    if (parts.length > 1) {
      let remotePodApi = "https://" + parts[1] + "/plugins/podcast2/router/getpoddata?channel=" + parts[0];
      try {
        remotePodData = await axios.get(remotePodApi);
      } catch (err) {
        console.log("🚧🚧hard error getting custom remote pod data for ", channel, "from", parts[1], remotePodApi, err);
        return res.status(400).send("🚧🚧hard error getting custom remote pod data for " + channel + " from " + parts[1] + " using " + remotePodApi + " error " + err);
      }
      if (remotePodData) {
        if (enableDebug){
          console.log("🚧🚧 found remote pod data", customChat.toString(), "for", channel);
        }
        await storageManager.storeData("pod-" + channel.replace(/\./g, "-"), req.body);
        return res.status(200).send(remotePodData.data);
      }
      console.log("🚧🚧 no remote pod data found for", channel);
      return res.status(404).send("🚧🚧 no podcast data for " + channel + " on remote system");
    }
    try {
      podData = await storageManager.getData("pod-" + channel.replace(/\./g, "-"));
    } catch (err) {
      console.log("🚧🚧error getting pod data for ", channel);
      return res.status(404).send("🚧🚧 no podcast data for " + req.query.channel + err);
    }
    if (podData) {
      return res.status(200).send(podData);
    } else {
      console.log("🚧🚧 no pod data found for", channel);
      return res.status(404).send("🚧🚧 no pod data found for " + channel);
    }
  })
  router.use('/setpoddata', async (req, res) => {
    if (enableDebug) {
      console.log("🚧🚧setting podcast data", req.query, req.body);
    }
    //TODO verify authorized user is actual owner of room
    let user = await peertubeHelpers.user.getAuthUser(res);
    if (user && user.dataValues && req.body) {
      let userName = user.dataValues.username;
      if (enableDebug) {
        console.log("🚧🚧🚧 got authorized peertube user to set pod data ", user.dataValues.username);
      }
      if (enableDebug) {
        console.log("🚧🚧🚧🚧 user", userName);
      }
      /*
      
      if (channel && req.body && (!req.body.feedguid || req.body.feedguid =='')) {
        try {
          channelGuid = await storageManager.getData("channelguid" + "-" + channel.replace(/\./g, "-"))
          if (channelGuid) {
            req.body.feedguid = channelGuid
          }
        } catch (err) {
          console.log("🚧🚧 error setting channel guid", channel,req.body.feedguid,err);
        }
      }
      */
      let channel = req.body.channel;
      if (enableDebug) {
        console.log("🚧🚧🚧🚧 poddata to save", channel, req.body);
      }
      if (channel){
        await storageManager.storeData("pod-" + channel.replace(/\./g, "-"), req.body);
        console.log("🚧🚧🚧🚧🚧🚧 clearing cache data for channel of livestream starting", channel,req.body.medium);
        await storageManager.storeData("rsscached-" + channel.replace(/\./g, "-"), 0);
        pingPI(channel,req.body.medium);
        return res.status(200).send();
      }
    }
    return res.status(420).send();
  })
  router.use('/importchannel', async (req, res) => {
    if (enableDebug) {
      console.log("🚧🚧importing channel data", req.query, req.body);
    }
    let feed;
    try {
      feed = await parser.parseURL(req.query.clone);
    } catch {
      console.log("error loading rss feed",req.query.clone);
      return res.status(420).send("hard error loading feed: "+req.query.clone);
    }
    if (!feed){
      console.log("error loading rss feed",req.query.clone);
      return res.status(420).send("error loading feed : "+req.query.clone);  
    }
    let header = req.body.bear;
    //TODO funding -> support
    let fixedName;
    if (feed.title){
      fixedName = feed.title.replace(/\W/g, '').toLowerCase();
      if (fixedName.length>40){
        fixedName =fixedName.slice(-38);
      }
    } else {
      console.log("🚧🚧🚧🚧 Unable to find channel name in provided feed", req.query.clone);
      return res.status(420).send("No Channel title found in stream:"+req.query.clone);
    }
    let getChannelApi = base+"/api/v1/video-channels/"+fixedName;
    let channelData;
    let channelId;
    let description
    let imageUrl;
    let displayName = feed.title.replace(/[^\w\s]/gi, '');
    if (feed.description){
      description = feed.description.replace(/[^\w\s]/gi, '')
      if (description.length>990){
        description = feed.description.slice(0,990);
      }
    }
    console.log("🚧🚧 new channel info",fixedName.length,displayName.length,description.length);
    try {
      channelData = await axios.get(getChannelApi);
    } catch (err) {
      console.log(`🚧🚧 no channel ${getChannelApi} found`);
    }
    if (channelData && channelData.data && channelData.data.id){
      channelId = channelData.data.id
      console.log("🚧🚧 got existing channel info ",channelData.data);
    } else {
      let newChannel ={
        "displayName": displayName,
        "name": fixedName,
        "description": description,
      }
      console.log("new channel object",newChannel,header);
      let result = await createChannel(newChannel,header);
      // console.log("🚧🚧 created channel",result.data, result.data.id, result.data.videoChannel.id);
      if (result && result && result.videoChannel && result.videoChannel.id){
        channelId = result.videoChannel.id;
      }
    }

    if (!channelId){
      console.log("🚧🚧 no channelId, unable to proceed");
      return res.status(420).send("No Channel ID found or created for :"+req.query.clone);
    }
    if (fixedName){
      let newChannelPath = base + `/c/${fixedName}`;
      console.log (`🚧🚧 redirecting to  ${newChannelPath}`);
      res.status(200).send(newChannelPath);
    } else {
      console.log (`🚧🚧 unable to redirect to  ${newChannelPath}`);
    }
    if (feed.image){
      imageUrl = feed.image.url;
      if (!imageUrl){
        imageUrl = feed.image.href;
      }
    }
    if (!imageUrl  && (typeof feedimage === 'string' || feed.image instanceof String)){
      imageUrl = feed.image;
    }
    if (!imageUrl && feed.itunes && feed.itunes.image){
      imageUrl = feed.itunes.image.url;
    }
    if (!imageUrl && feed.itunes && feed.itunes.image){
      imageUrl = feed.itunes.image;
    } 
    if (!imageUrl){
      console.log("🚧🚧 no  image url",feed.itunes);
    }
    console.log("🚧🚧final image url",imageUrl);
    let avatarResult = await updateChannelAvatar(imageUrl,fixedName,header);
    console.log("🚧🚧 avatar upload result",avatarResult)
    await storageManager.storeData("pod-" + fixedName.replace(/\./g, "-"), {"medium": "podcast", "channel": fixedName});
    console.log("🚧🚧 Starting to process rss stream items",channelId,fixedName,feed.title);     
    for (var item of feed.items){
      item.channelId = channelId;
      let importBody = await rssJsonToApiJson(item);
      console.log("🚧🚧 json", item, importBody);
      let dupeResult = await checkForDuplicate(importBody);
      if (dupeResult){
        console.log("🚧🚧 skipping duplicate");
        continue;
      }
      let importApi = base+"/api/v1/videos/imports";
      
      let result;
      try {
        result = await axios.post(importApi,importBody,{ headers: header });
      } catch (err){
        console.log("🚧🚧 hard error importing podcast",importApi,importBody,header,err);
      }
    }
  })
  router.use('/importarc', async (req, res) => {
    if (enableDebug) {
      console.log("🚧🚧importing from internet archive", req.query, req.body);
    }
    let ID = req.query.id;
    if (!ID) {
      ID = "little_fuzzy_0911_librivox";
    }
    //let ID = "spacelinerx87_2402_librivox";
    //let ID ="little_fuzzy_0911_librivox";
    let metadataApi = "https://archive.org/metadata/"+ID;
    let data,baseUrl,title,author,description,thumbnail;
    let season = 1;
    console.log(`🚧🚧 trying`,ID,metadataApi);
    try {
      data = await axios.get(metadataApi);
      console.log(`🚧🚧 found data ${data}`,data);
    } catch (err) {
      console.log(`🚧🚧 unable to get metadata at ${metadataApi}`,err);
    }
    dirtyHack= data.data;
    data = data.data;
    let shows = []
    if (data && data.metadata) {
      baseUrl = "https://"+data.d1+data.dir;
      author = data.metadata.creator;
      title = data.metadata.title;
      
      if (Array.isArray(data.metadata.description)){
        console.log(`🚧🚧 description array `, data.metadata.description,"\nfirst",data.metadata.description[0]);
        description = data.metadata.description[0];
      } else {
        description = data.metadata.description;
      }
      console.log(`🚧🚧 found metadata for ${title} by ${author}`);
      let line = "checking";
      //return res.status(200).send(data);
      for (var file of data.files ){
        let show={};
        let format = file.format;
        if (format.toLowerCase().includes("mp3")){
          line = line+"<br>"+`🚧🚧 ${format} ${file.size} ${file.name} ${file.album} ${file.title} ${file.track}`
          
          if (file.track){
            show.track = parseInt(file.track);
          }
          if (file.title){
            show.title = file.title;
          }
          if (file.size){
            show.size = parseInt(file.size);
          }
          if (file.album){
            show.album = file.album;
          }
          if (file.name){
            show.name = file.name;
            show.fullPath = baseUrl+"/"+file.name
          }
          if (file.format){
            show.format = file.format;
          }
          let duplicate = false;
          for (var current in shows){
            if (shows[current].title == show.title){
              duplicate=true;
              console.log(`🚧🚧 matched `,shows[current],shows[current].size,show.size);
              if (shows[current].size < show.size){
                console.log(`🚧🚧 replacing smaller show `,show,shows[current].size,show.size);
                shows[current]=show;
              } else {
                break;
              }
            }
          }
          if (!duplicate){
            shows.push(show);
          }

        }
      }
      
      for (var file of data.files ){
        let format = file.format;
        if (format.toLowerCase() == "jpeg"){
          thumbnail = baseUrl+"/"+file.name;
        }
        if (format.toLowerCase().includes("png") || format.toLowerCase().includes("jpg") || format.toLowerCase().includes("gif")){
          let partial = file.name.split(".")[0];
          for (var current in shows){
            if (shows[current].name.toLowerCase().includes(partial)){
              shows[current].thumbnail = baseUrl+"/"+file.name;
            }
          }
        }  
      }
      if (thumbnail){
        for (var show of shows) {
          if (!show.thumbnail){
            show.thumbnail = thumbnail
          }
        }
      }
      console.log(`🚧🚧 shows `,shows);
      let header = req.body.bear;
      let fixedName,channelName;
      if (author) {
        channelName = author +" - "+title;
      } else {
        channelName = title;
      }
      if (channelName){
        fixedName = channelName.replace(/\W/g, '').toLowerCase();
        if (fixedName.length>40){
          fixedName =fixedName.slice(-38);
        }
      } else {
        console.log("🚧🚧🚧🚧 Unable to find channel name in archive metadata", req.query.id);
        return res.status(420).send("No Channel title found in stream:"+req.query.id);
      }
      let getChannelApi = base+"/api/v1/video-channels/"+fixedName;
      let channelData;
      let channelId;
      let imageUrl;
      let displayName = title.replace(/[^\w\s]/gi, '');
      if (description){
        //description = description.replace(/[^\w\s]/gi, '')
        if (description.length>990){
          description = description.slice(0,990);
        }
      }
      console.log("🚧🚧 new channel info",fixedName.length,displayName.length,description.length);
      try {
        channelData = await axios.get(getChannelApi);
      } catch (err) {
        console.log(`🚧🚧 no channel ${getChannelApi} found`);
      }
      if (channelData && channelData.data && channelData.data.id){
        channelId = channelData.data.id
        console.log("🚧🚧 got existing channel info ",channelData.data);
      } else {
        let newChannel ={
          "displayName": displayName,
          "name": fixedName,
          "description": description,
        }
        console.log("new channel object",newChannel,header);
        let result = await createChannel(newChannel,header);
        // console.log("🚧🚧 created channel",result.data, result.data.id, result.data.videoChannel.id);
        if (result && result && result.videoChannel && result.videoChannel.id){
          channelId = result.videoChannel.id;
        }
      }
  
      if (!channelId){
        console.log("🚧🚧 no channelId, unable to proceed");
        return res.status(420).send("No Channel ID found or created for :"+req.query.clone);
      }
      if (fixedName){
        let newChannelPath = base + `/c/${fixedName}`;
        console.log (`🚧🚧 redirecting to  ${newChannelPath}`);
        res.status(200).send(newChannelPath);
      } else {
        console.log (`🚧🚧 unable to redirect to  ${newChannelPath}`);
      }
      if (thumbnail){
        imageUrl = thumbnail;
      }
      if (!imageUrl){
        console.log("🚧🚧 no  image url",thumbnail);
      }
      console.log("🚧🚧final image url",imageUrl);
      let avatarResult = await updateChannelAvatar(imageUrl,fixedName,header);
      console.log("🚧🚧 avatar upload result",avatarResult)
      await storageManager.storeData("pod-" + fixedName.replace(/\./g, "-"), {"medium": "audiobook", "channel": fixedName});
      console.log("🚧🚧 Starting to process internet archive items",channelId,fixedName,title,shows.length);     
      for (var show  of shows){
        show.channelId = channelId;
        let importBody = await showJsonToApiJson(show);
        //console.log("🚧🚧 json", show, importBody);
        if (enableDebug) {
          console.log("🚧🚧 attemptin to get", show);
        }
        let dupeResult = await checkForDuplicate(importBody);
        if (dupeResult){
          console.log("🚧🚧 skipping duplicate");
          continue;
        }
        let importApi = base+"/api/v1/videos/imports";
        
        let result;
        try {
          result = await axios.post(importApi,importBody,{ headers: header });
        } catch (err){
          console.log("🚧🚧 hard error importing podcast",importApi,err);
        }
        //console.log(`🚧🚧 result of importing Video 🚧🚧`,result,show);
        if (result && result.data && result.data.video){
          let videoId = result.data.video.id;
          let videoUuid = result.data.video.uuid;
          let videoUrl = result.data.video.url;
          let videoThumbnail = result.data.video.thumbnailPath;
          let videoPreview = result.data.video.previewPath
          if (show.track){
            await storageManager.storeData('episodenode-' + videoId, show.track);
            await storageManager.storeData('seasonnode-' + videoId, 1);
          }
          if (show.title){
            await storageManager.storeData('episodename-' + videoId, show.title);
          }
          //conflicts with youtube data streamings.
          //storageManager.storeData('sourceid-' + videoId, ID);
        }
      }
      pingPI(fixedName);
      //return res.status(200).send(line);
    } else {
      console.log(`🚧🚧 missing metadata or meta meta`);
      return res.status(420).send("failed to get data or metadata");;
    }
  })
  router.use(`/piproxy`,async (req, res) => {
    console.log("🚧🚧 starting proxy ping ", req.query);


    let url = req.query.url;
    let reason = req.query.reason;
    let medium = req.query.medium;
    if (!url || !piKey){
      return res.status(420).send("🚧🚧 Missing URL or api key to ping ");
    }
   let podpingUrl = `https://podping.cloud/?url=${encodeURIComponent(url)}`;
   //let podpingUrl = `https://podping.cloud?url=${url}`;
    if (medium){
      podpingUrl = podpingUrl + "&medium="+medium;
    }
    if (reason){
      podpingUrl = podpingUrl + "&reason="+reason;
    }
    console.log("🚧🚧 time to ping the proxy ", podpingUrl);
    let head = { headers: { Authorization: piKey } }
    let pingResult;
    try {
      pingResult = await axios.get(podpingUrl,head);
    } catch (err) {
      console.log("🚧🚧hard error when pod pinging ", podpingUrl, head ,err);
    }
    if (pingResult && pingResult.data) {
        console.log("🚧 pod Pinged", podpingUrl,pingResult.data);
        return res.status(200).send(pingResult.data);
    } else {
      console.log("🚧 i am disappoint", pingResult, podpingUrl);
      return res.status(420).send(pingResult);
    }
  })
  async function pingPI(channel,medium,reason) {
      console.log("🚧attempting to pod ping", channel);
    if (!channel){
      console.log("🚧no channel to podping", channel);
      return;
    }
    if (!reason) {
      reason = 'live';
    }
    if (!medium){
      medium="video"
    }
    let feedUrl = encodeURIComponent(`${base}/plugins/podcast2/router/podcast2?channel=${channel}`);
    let podpingUrl = `https://podping.cloud/?url=${feedUrl}`;
    
    if (medium){
      podpingUrl = podpingUrl + "&medium="+medium;
      feedUrl = feedUrl + "&medium="+medium;
    }
    if (reason){
      podpingUrl = podpingUrl + "&reason="+reason;
      feedUrl = feedUrl + "&reason="+reason;
    }
    let feedApi = base + "/plugins/podcast2/router/getfeedid?channel=" + channel;
    let feedId,pingResult;
    
    /*if (!piKey){
      try {
        feedId = await axios.get(feedApi);
      } catch (err){
        console.log("🚧🚧hard error getting feedid from podcast2 to ping podcast index ", feedId, feedApi,err);
      }
      if (!feedId){
        feedApi = base + "/plugins/lightning/router/getfeedid?channel=" + channel;
        try {
          feedId = await axios.get(feedApi);
        } catch (err){
          console.log("🚧🚧hard error when getting feedid from lightning to ping podcast index ", feedId, feedApi,err);
        }
      }
      if (feedId && feedId.data) {
        console.log("🚧🚧feed ID for podping ", feedId, );
        indexTickle=`https://api.podcastindex.org/api/1.0/hub/pubnotify?id=${feedId.data}`
        try {
          pingResult = await axios.get(indexTickle);
        } catch (err) {
          console.log("🚧🚧hard error updating podcast index ", feedId, feedApi,err);
        }
      } else {
        console.log("🚧 podcast update badness", feedId);
      }
    } 
    */
    let head;
    console.log("🚧 podping troubleshooting", piKey, piProxy, feedUrl,podpingUrl);
    if (piKey) {
      head = { headers: { Authorization: piKey } }
      try {
        pingResult = await axios.get(podpingUrl,head);
        console.log("🚧 pod pinged, result", podpingUrl);
      } catch (err) {
        console.log("🚧🚧hard error when pod pinging ", podpingUrl, head ,err);
      }
    } else if (piProxy){
      let proxyUrl=piProxy+`/plugins/podcast2/router/piproxy?url=${feedUrl}`
      try{
        pingResult = await axios.get(proxyUrl);
        console.log("🚧 proxy pod pinged, result", proxyUrl,pingResult);
      } catch (err){
        console.log("🚧🚧hard error when proxy pod pinging ", proxyUrl,err);
      }
    }
    if (pingResult && pingResult.data) {
        console.log("🚧 pod Pinged", channel, pingResult.data);
      return (pingResult.data);
    } else {
      console.log("🚧 i am disappoint", podpingUrl,proxyUrl);
    }
    //TODO add some kind of feed id reed to use pubnotify
    return;
  }
  async function getRss(channel){
    let apiUrl = base + "/api/v1/video-channels/" + channel;
    let channelData;
    try {
      channelData = await axios.get(apiUrl);
      console.log("🚧🚧🚧🚧 getting rss base for", channelData.data);
    } catch {
      console.log("🚧🚧🚧🚧unable to load channel info", apiUrl);
      return ;
    }
    
    let rssUrl = base + "/feeds/podcast/videos.xml?videoChannelId="+channelData.data.id
    return rssUrl;
  }
  async function getConfigPanel(splitInfo, channel) {
    let feedID = await getFeedID(channel);
      console.log("🚧getting config panel", splitInfo, feedID, channel);
    let html = `<br><label _ngcontent-msy-c247="" for="Wallet">Lightning Splits</label><br>`
    if (splitInfo && (keysendEnabled || lnurlEnabled)) {
      if (splitInfo.length > 0) {
        html = html + "<table><th>Split %</th><th><center>Lighting Address</center></th><th>Address Type</th></tr>";
        for (var split in splitInfo) {
          let displayName = splitInfo[split].name;
          if (!displayName) {
            displayName = splitInfo[split].address;
          }
          html = html + "<tr><td>" + splitInfo[split].split + "</td><td>" + displayName + "</td>";
          if (splitInfo[split].keysend) {
            html = html + `<td>Keysend</td>`;
          } else if (splitInfo[split].customKeysend) {
            html = html + `<td>Node</td>`;
          } else if (splitInfo[split].lnurl) {
            html = html + "<td>LNURL Pay</td>";
          } else {
            html = html + "<td>unknown</td>"
          }
          if (!splitInfo[split].fee) {
            html = html + `<td><div class="peertube-button orange-button ng-star-inserted" slot="` + split + `" id="edit-` + split + `">edit</div></td>`;
            //html = html + `<td><button class="peertube-button orange-button ng-star-inserted" >edit</button></td>`;
          }
          html = html + "</tr>";
        }
        html = html + "</table>";
      }
      html = html + `<button type="button" id="add-split" class="peertube-button orange-button ng-star-inserted">Add Split</button>`
    } else {
      html = html + `<button type="button" id="create-split" class="peertube-button orange-button ng-star-inserted">Add Lightning Address</button>`

    }
    if (rssEnabled) {
      html = html + "<hr>"
      html = html + `<button type="button" id="rss-settings" name="ress-settings" class="peertube-button orange-button ng-star-inserted">Podcasting 2.0 RSS settings</button>`;
    }


    html = html + "<hr>"

    //html = html + "<br>podcast 2.0 RSS feed URL: " + rssFeedUrl;
    const panel = document.createElement('div');
    panel.setAttribute('class', 'lightning-button');
    panel.setAttribute('sandbox', 'allow-same-origin allow-scripts allow-popups allow-forms')
    panel.innerHTML = html;
    return panel;
  }
  async function getImage(imageUrl,channel,header){
    console.log("🚧oh boy, this again",imageUrl,channel,header);
    if (!imageUrl){
      return undefined;
    }
    var fileName = channel + "-avatar.jpg";
    var downloader = new Downloader({
      url: imageUrl,
      directory: basePath + "/avatars",
      fileName: fileName,
      cloneFiles: false
    })
    try {
      var avatarDownloadResult = await downloader.download();
      console.log('🚧downloaded', avatarDownloadResult);
    } catch (error) {
      console.log('🚧Download failed', fileName, error)
    }
    console.log("🚧avatar  downloaded", avatarDownloadResult);
    form = new FormData;
    form.append( 'avatarfile', fs.createReadStream(basePath + '/avatars/'+fileName, {filename: 'bar.jpg', contentType: 'image/jpeg'} ));
    const formHeaders = form.getHeaders();
    console.log("🚧 form headers",formHeaders);
    let mergeheaders = {
      ...header,
      ...formHeaders,
    }
    console.log("🚧 form headers2",formHeaders);
    let avatarUrl = base+`/api/v1/video-channels/${channel}/avatar/pick`;
    await axios.post(avatarUrl, form, {
      headers: {
        ...mergeheaders,
      },
    })
      .then(response => response)
      .catch(error => error)
      return ;
    /*

    let dataString = fs.createReadStream(basePath + "/avatars/" + fileName)
    //return dataString;
    let gorf = new FormData()
    gorf.append('avatarfile', dataString)
    console.log("🚧🚧 fs on downloaded file version",gorf);
    * /
    let data;
    try {
      data = await imageDataURI.encodeFromURL(imageUrl);
    } catch (err) {
      console.log("🚧🚧 Hard error getting image from url",imageUrl);
    }
    let gank = new FormData()
    gank.append('avatarfile',data);
    gank.append('filename',"eatme.jpg");
    console.log("imageDataURI version",gank, "\n\n\n\n\n\n\n",gank._streams[0]);
    return gank._streams[0];
    
    try {
      request.defaults({ encoding: null });
      request.get('imageUrl', function (error, response, body) {
          if (!error && response.statusCode == 200) {
              data = "data:" + response.headers["content-type"] + ";base64," + Buffer.from(body).toString('base64');
              console.log("🚧🚧 image string",data,new FormData().append('avatarfile', data));
          }
      });
    } catch {
      console.log("🚧🚧 stuff done blown up");  
    }
    let image = await axios.get(imageUrl, {responseType: 'arraybuffer'});
    let returnedB64 = Buffer.from(image.data).toString('base64');
    let geek = new FormData()
    geek.append('avatarfile', returnedB64);
    console.log("🚧🚧 axios get version ", geek,);
  */
  var form = new FormData();

//form.append('my_field', 'my value');
//form.append('my_buffer', new Buffer(10));
form.append('avatarfile', request(imageUrl));
form.submit('http://example.org/', function(err, res) {
  // res – response object (http.IncomingMessage)  //
  res.resume();
  console.log("res");
});
  }
  async function setTranscript(transcriptUrl,channel,language, header,){
    console.log("🚧oh boy, this again",transcriptUrl,channel,language, header);
    if (!transcriptUrl){
      return undefined;
    }
    var fileName = channel + "-transcript.txt";
    var downloader = new Downloader({
      url: transcriptUrl,
      directory: basePath + "/transcript",
      fileName: fileName,
      cloneFiles: false
    })
    try {
      var transcriptDownloadResult = await downloader.download();
      console.log('🚧downloaded', transcriptDownloadResult);
    } catch (error) {
      console.log('🚧Download failed', fileName, error)
    }
    console.log("🚧avatar  downloaded", transcriptDownloadResult);
    form = new FormData;
    form.append( 'transcriptfile', fs.createReadStream(basePath + '/transcripts/'+fileName, {filename: fileName, contentType: 'text/txt'} ));
    const formHeaders = form.getHeaders();
    console.log("🚧 form headers",formHeaders);
    let mergeheaders = {
      ...header,
      ...formHeaders,
    }
    console.log("🚧 form headers2",formHeaders);
    let avatarUrl = base+`/api/v1/video-channels/${channel}/avatar/pick`;
    await axios.post(avatarUrl, form, {
      headers: {
        ...mergeheaders,
      },
    })
      .then(response => response)
      .catch(error => error)
      return ;

  var form = new FormData();

//form.append('my_field', 'my value');
//form.append('my_buffer', new Buffer(10));
form.append('avatarfile', request(imageUrl));
form.submit('http://example.org/', function(err, res) {
  // res – response object (http.IncomingMessage)  //
  res.resume();
  console.log("res");
});
  }
  async function rssJsonToApiJson(rss){
    if (!rss){
      console.log("🚧🚧 no rss");
      return
    }
    let api = {}
    if (!rss.channelId || !rss.title || !rss.enclosure){
      return false;
    }

    if (rss.content){
      if (rss.content.length>990){rss.content=rss.content.slice(0,990)}
      api.description=rss.content;
    }
    api.nsfw = false;
    api.language = "en";
    api.privacy = 1;
    api.channelId = rss.channelId;
    api.name = rss.title;
    if (api.name.length>119){
      api.name = api.name.slice(0,119);
    }
    if (rss.enclosure){
      api.targetUrl = rss.enclosure.url;
    }
    if (rss.category){
      console.log("TODO category conversion is hard, check rss2peertube for help");
    }
    if ( rss && rss.itunes && rss.itunes.explicit && rss.itunes.explicit.toLowerCase() == "yes"){
      api.nsfw=true;
    }
    if (rss.isoDate){
      api.originallyPublishedAt = rss.isoDate;
    }
    if (rss.value){
      api.support = rss.value;
    }
    let imageUrl;
    console.log("itunes",rss.itunes,"image",rss.image);
    if (rss.itunes){
      if (rss.itunes.image && rss.itunes.image.url){
        imageUrl=rss.itunes.image.url;
      } else if (rss.itunes.image && rss.itunes.image.href){
        imageUrl =rss.itunes.image.href;
      } else if (rss.itunes.image){
        imageUrl = rss.itunes.image;
      }
    }
    if (rss.image){
      if (rss.image.url){
        imageUrl=rss.image.url;
      } else {
        if (rss.image.href){
          imageUrl =rss.image.href;
        }else {
          imageUrl = rss.image;
        }
      }
    } 
    console.log("🚧🚧 found image",imageUrl); 
    if (imageUrl){
      api.thumbnailfile=await getThumbnail(imageUrl);
    }
    console.log(" what we're laying down",api,"thumbnail",api.thumbnailfile, "buffer",api.buffer);
    return api;
  }
  async function showJsonToApiJson(show){
    if (!show){
      console.log("🚧🚧 show json",show);
      return
    }
    let api = {}
    /*
    if (!rss.channelId || !rss.title || !rss.enclosure){
      return false;
    }
*/
    if (show.description){
      if (show.descripton.length>990){
        show.description=show.description.slice(0,990)
      }
      api.description=show.description;
    }
    api.nsfw = false;
    api.language = "en";
    api.privacy = 1;
    api.channelId = show.channelId;
    api.name = show.title;
    if (api.name && api.name.length>119){
      api.name = api.name.slice(0,119);
    }
    if (show.fullPath){
      api.targetUrl = encodeURI(show.fullPath);
    }
    let imageUrl = show.thumbnail;
    console.log("🚧🚧 found image",imageUrl); 
    if (imageUrl){
      api.thumbnailfile=await getThumbnail(imageUrl);
    }
    console.log("returned json api",api);
    return api;
  }
  async function createChannel(channel,header ){
    console.log("🚧🚧 creating channel",channel,header);
    let url = base+"/api/v1/video-channels";
    try {
      let result = await axios.post(url,channel,{ headers: header });
      if (result){
        return result.data;
      } else {
        return undefined
      }
    } catch (err){
      console.log("🚧🚧 error creating channel",channel,header,err);
      return undefined;
    }
  }
  async function updateChannelAvatar(imageUrl, channel,header ){
    console.log(`🚧 updateing ${channel} avatar to ${imageUrl}`);
    if (!imageUrl || !channel || !header ){
      console.log('🚧bad or missing arguments',imageUrl,channel,header);
      return undefined;
    }
    var fileName = channel + "-avatar.jpg";
    var downloader = new Downloader({
      url: imageUrl,
      directory: basePath + "/avatars",
      fileName: fileName,
      cloneFiles: false
    })
    try {
      var avatarDownloadResult = await downloader.download();
      console.log('🚧downloaded', avatarDownloadResult);
    } catch (error) {
      console.log('🚧Download failed', fileName, error)
    }
    console.log("🚧avatar  downloaded", avatarDownloadResult);
    form = new FormData;
    await form.append( 'avatarfile', fs.createReadStream(basePath + '/avatars/'+fileName, {filename: 'bar.jpg', contentType: 'image/jpeg'} ));
    const formHeaders = form.getHeaders();
    console.log("🚧 form headers",formHeaders);
    let mergeheaders = {
      ...header,
      ...formHeaders,
    }
    console.log("🚧 form headers2",formHeaders);
    let avatarUrl = base+`/api/v1/video-channels/${channel}/avatar/pick`;
    let avatarResult;
    try {
      avatarResult = await axios.post(avatarUrl, form, {
        headers: {
          ...mergeheaders,
        },
      })
    } catch (err) {
      console.log("🚧 error setting avatar",err )
    }
      return avatarResult;
  }
  async function getInstanceChannels(){
    //let apiUrl = `${base}/api/v1/video-channels?count=100`;
    let channelSpot=0
    let localChannels=[];
    let apiUrl = `${base}/api/v1/video-channels?count=100&start=${channelSpot}`;
    let channelData;
    try {
      channelData = await axios.get(apiUrl);
    } catch (err) {
      console.log("⚓⚓⚓⚓unable to load channel video info", apiUrl,err);
      return;
    }
    if (enableDebug) {
     // console.log("⚓⚓⚓⚓ instance channel Data",channelData.data.total,channelData.data.data);
    }
    let totalChannels = channelData.data.total;
    while (channelSpot <totalChannels){
      for (var channel of channelData.data.data){

        if (channel.isLocal){
          localChannels.push(channel);
          console.log(channel.url);
        }
      }
      channelSpot=channelSpot+100
      apiUrl = `${base}/api/v1/video-channels?count=100&start=${channelSpot}`;
      try {
        channelData = await axios.get(apiUrl);
      } catch (err) {
        console.log("⚓⚓⚓⚓unable to load channel video info", apiUrl,err);
        return;
      }
    }
    return localChannels;
  }
  async function getChannelPodroll(accountName){
    //let apiUrl = `${base}/api/v1/accounts/video-channels?count=100`;
    let channelSpot=0
    let podroll=[];
    let apiUrl = `${base}/api/v1/accounts/${accountName}/video-channels?count=100&start=${channelSpot}`;
    let channelData;
    try {
      channelData = await axios.get(apiUrl);
    } catch (err) {
      console.log("🚧🚧 unable to load channel video info", apiUrl,err);
      return;
    }
    if (enableDebug) {
      console.log("🚧🚧  channels ",channelData.data.total);
    }
    let totalChannels = channelData.data.total;
    while (channelSpot <totalChannels){
      for (var channel of channelData.data.data){
        let podData;
        try {
          podData = await storageManager.getData("pod-" + channel.name.replace(/\./g, "-"));
          //console.log("⚓⚓⚓⚓ pod data", podData);
        } catch (err) {
          console.log("🚧🚧hard error getting pod data for ", channel);
          //return res.status(404).send("🚧🚧 no podcast data for " + req.query.channel + err);
        }
          if (podData && podData.feedguid){
          podroll.push(podData.feedguid);
          //console.log("🚧🚧 pushed guid ",podData);
        }
      }
      channelSpot=channelSpot+100
      apiUrl = `${base}/api/v1/accounts/${accountName}/video-channels?count=100&start=${channelSpot}`;
      try {
        channelData = await axios.get(apiUrl);
      } catch (err) {
        console.log("🚧🚧 unable to load channel video info", apiUrl,err);
        return;
      }
    }
    return podroll;
  }
  async function getThumbnail(imageUrl){
    console.log(`🚧 getting thumbnail from ${imageUrl}`);
    if (!imageUrl){
      console.log('🚧bad or missing arguments',imageUrl);
      return undefined;
    }
    var parts = imageUrl.split("/");
    var fileName = parts.pop();
    var downloader = new Downloader({
      url: imageUrl,
      directory: basePath + "/thumbnails",
      fileName: fileName,
      cloneFiles: false
    })
    try {
      var thumbnailloadResult = await downloader.download();
      console.log('🚧downloaded', thumbnailloadResult);
    } catch (error) {
      console.log('🚧Download failed', fileName, error)
      return;
    }
    console.log("🚧thumbnail downloaded", thumbnailloadResult);
    form = new FormData;
    await form.append( 'thumbnailfile', fs.createReadStream(basePath + '/thumbnails/'+fileName, {filename: fileName, contentType: 'image/jpeg'} ));
    console.log("🚧 form ",form);
    return form;
  }  
  async function getPeerTubeToken(username, password) {
    var clientTokenPath = base + "/api/v1/oauth-clients/local";
    var userTokenPath = base + "/api/v1/users/token";
    try {
      let clientResult = await axios.get(clientTokenPath);
      if (clientResult && clientResult.data) {
        let peertubeClientId = clientResult.data.client_id;
        let clientSecret = clientResult.data.client_secret;
        var data = new URLSearchParams();
        data.append('client_id', peertubeClientId);
        data.append('client_secret', clientSecret);
        data.append('grant_type', 'password');
        data.append('response_type', 'code');
        data.append('username', username);
        data.append('password', password);
        var postData = data.toString();
        let tokenresponse = await axios.post(userTokenPath, data);
        console.log("token request respoonse", tokenresponse.data);
        bearerToken = tokenresponse.data.access_token;
        return (bearerToken);
      } else {
        console.log("failed to get client token");
      }
    } catch (error) {
      console.log("error in get token", ptuser, ptpassword, ptApi);
      return (-1);
    }
    return;
  }
  async function checkForDuplicate(itemJson){
    console.log("🚧 looking fo dips",itemJson);
    let eSearch = encodeURIComponent(itemJson.name);
    let searchApi = base+`/api/v1/search/videos?search=${eSearch}`;
    try {
      searchResult = await axios.get(searchApi);

    } catch (err) {
      console.log("🚧 hard error trying to search for video dupes ",searchApi,err);
    }
    if (searchResult && searchResult.data && searchResult.data && Array.isArray(searchResult.data)){
      for (var match of searchResult.data){
        console.log("🚧 found these dupes",match.channel);
      }
    } else {
      console.log("🚧 no result from search, should be unique");
      return (false)
    }
  }
  async function isUUID ( uuid ) {
    let s = "" + uuid;

    s = s.match('^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$');
    if (s === null) {
      return false;
    }
    return true;
  }
  async function getUUID (enclosureUrl){
/*    //dirty hack supporting dirty hack
    let parts = enclosureUrl.split("/");
    for (var url of parts) {
      console.log("🚧 url part",url,url.length);
      if (url.length>50){
        let urlParts=url.split("-");
        for (var count in urlParts){
          console.log("🚧 uuid parts",count, urlParts[count],urlParts[count].length);
          if (count > urlParts.length-4){
            return false;
          }
          c=count;
          let realUUID = `${urlParts[c]}-${urlParts[c+1]}-${urlParts[c+2]}-${urlParts[c+3]}-${urlParts[c+4]}`
          console.log("🚧 uuid candidate",realUUID);
          if (urlParts[count].length == 8 && urlParts[count+1] == 4 && urlParts[count+2].length == 4 && urlParts[count+3] == 4 && urlParts[count+4] == 12){
            return (realUUID);
          }
        }

      }
  */
    let parts = enclosureUrl.split("/");
    let foundUUID = parts[5].substring(0,36);
    //console.log("🚧 parts",parts,foundUUID);

    return foundUUID;
  }
}
async function unregister () {
  return
}

module.exports = {
  register,
  unregister
}