// we can use this for user flow token service for normal searching etc.
  // this one won't work with .counts()
  const goa = makeTwitterGoa()
  
  // for counts we'll use a different service
  // app only oauth
  const goaApp = makeTwitterGoaAppOnly()
  
  
  // here's how to make an app only token service
  // this is the one you'll need for .counts()
  // SETTINGS
  /*
  {
    twitterAppOnly: {
    propertyService: PropertiesService.getScriptProperties(),
    name: 'twitterAppOnly'
  }}
  */
  const makeTwitterGoaAppOnly = () => {
	
	const { twitterAppOnly } = SETTINGS
	return cGoa.make(
      twitterAppOnly.name,
      twitterAppOnly.propertyService,
   )
 }
  
 
  
  
  

  // import required modules
  const { Plugins, SuperFetch } = bmSuperFetch
  const { Twt } = Plugins

  // for .counts() we need an app only Oauth2 token service service
  const superFetchApp = new SuperFetch({
    fetcherApp: UrlFetchApp,
    tokenService: goaApp.getToken,
    cacheService: CacheService.getScriptCache(),
  })

  
  // clone and user the app only superfetch instance
  const twtApp = new Twt({
    superFetch: superFetchApp
  })
  
 

  // get lastest tweets about apps script
  // we need app only auth for counting
 const data = twtApp.tweets.counts("Apps Script").throw().data

/**
 * This is the response from the apply proxied function
 * @typedef PackResponse
 * @property {boolean} cached whether item was retrieved from cache
 * @property {object||null} data parsed data
 * @property {number} age age in ms of the cached data
 * @property {Blob|| null} blob the recreated blob if there was one
 * @property {boolean} parsed whether the data was parsed
 * @property {HttpResponse} response fetch response
 * @property {function} throw a function to throw on error
 * @property {Error || string || null} the error if there was one
 * @property {number} responseCode the http response code 
 * @property {string} url the url that provoked this response
 * @property {string} pageToken optional restart point passed back in the page paramter
 */
 console.log(Object.keys(bunch))
[ 'response',
  'data',
  'error',
  'parsed',
  'blob',
  'age',
  'cached',
  'responseCode',
  'url',
  'throw',
  'pageToken' ]

console.log(Object.keys(data))	
[ 'items']

 
 console.log(data.items)

  /* looks like this by hour
  [{ end: '2022-06-23T19:00:00.000Z',
    start: '2022-06-23T18:00:00.000Z',
    tweet_count: 5 }, ... ]
  */
  

// simple query
twtApp.tweets.counts("Apps Script").throw().data


// is equivalent to
const query = twtApp.tweets.query({query: "Apps Script"})
query.counts().throw().data

 console.log(twtApp.tweets.counts("Apps Script", { granularity: 'day' }).throw().data.items)
 
 // you can also create a reusable closure
  const dayQuery = twtApp.tweets.query({fields: { granularity: 'day' }})
  console.log(dayQuery.counts("Apps Script").data.items)

  // error handling
  // data will be in result.data
  const hResult = tweets.counts (queryString)
  if (hResult.error) {
    // handle it yourself
    console.log(hResult.error)
  }
  // throw an error if there is one
  // data will still be in result.data
  const iResult = tweets.counts (queryString).throw()

twtApp.tweets.recent.counts("Apps Script").throw().data.items

 console.log(twt.tweets.all.counts("Google Apps Script").throw().data.items) // error
/*
Error: {
"client_id":"xxxxx",
"detail":"When authenticating requests to the Twitter API v2 endpoints, you must use keys and tokens from a Twitter developer App that is attached to a Project. You can create a project via the developer portal.",
"registration_url":"https://developer.twitter.com/en/docs/projects/overview",
"title":"Client Forbidden",
"required_enrollment":"Standard Basic","
reason":"client-not-enrolled",
"type":"https://api.twitter.com/2/problems/client-forbidden"
}
*/

  unit.section(() => {
    // some of the api endpoint require credential OAuth
    const goa = makeTwitterGoaAppOnly()
    // we need a different tokenService
    const superFetch = new SuperFetch({
      fetcherApp: UrlFetchApp,
      tokenService: goa.getToken,
      cacheService: CacheService.getUserCache(),
      missingPropertyIsFatal: true,
      showUrl: true
    })
    const twt = new Twt({
      superFetch,
      noCache: true
    })
    const tn = twt.ref({ noCache: true }).tweets
    const tc = twt.ref({ noCache: false }).tweets
    const query = "Apps Script"

    const cQuery = tc.query({ query })
    const nQuery = tn.query({ query })

    const { actual: counts } = unit.not(null, nQuery.counts().throw(), {
      description: 'counts per hour for query'
    })
    unit.is('number', typeof counts.data.items[0].tweet_count, {
      description: 'count is a number'
    })
    const total = (items) => items.reduce((p, c) => p   c.tweet_count, 0)
    const { actual: seed } = unit.not(null, cQuery.counts().throw(), {
      description: 'seeding cache'
    })
    unit.is(false, seed.cached, {
      description: 'seed wasnt cached'
    })
    unit.is(total(counts.data.items), total(seed.data.items), {
      description: 'same tweet total'
    })
    unit.is(true, cQuery.counts().throw().cached, {
      description: 'seed is cached'
    })
    unit.is(seed.data, cQuery.counts().throw().data, {
      description: 'cache matches seed'
    })
    const {actual: days} = unit.not (null ,tn.counts(query, { granularity: 'day' }) ,{
      description: 'daily counts'
    })
    unit.is (8 ,tn.counts(query, { granularity: 'day' }).data.items.length ,{
      description: '8 day inclusive count'
    })
  }, {
    description: "counts",
    skip: skipTest.tweetCounts
  })