/**

* Contains the [[DateFolder]] class

* This tracks data stored in dated folders and sub-folders

*

*/

import * as debug from '../debug'

import { store } from 'solid-logic'

import * as ns from '../ns'

import * as $rdf from 'rdflib' // pull in first avoid cross-refs

/**

* Track back through the YYYY/MM/DD tree to find the previous/next day

*/

export class DateFolder {

constructor (rootThing, leafFileName, membershipProperty) {

this.root = rootThing

this.rootFolder = rootThing.dir()

this.leafFileName = leafFileName || 'index.ttl' // typically chat.ttl

this.membershipProperty = membershipProperty || ns.wf('leafObject')

}

/* Generate the leaf document (rdf object) from date

* @returns: <NamedNode> - document

*/

leafDocumentFromDate (date) {

// debug.log('incoming date: ' + date)

const isoDate = date.toISOString() // Like "2018-05-07T17:42:46.576Z"

let path = isoDate.split('T')[0].replace(/-/g, '/') // Like "2018/05/07"

path = this.root.dir().uri + path + '/' + this.leafFileName

return store.sym(path)

}

/* Generate a date object from the leaf file name

*/

dateFromLeafDocument (doc) {

const head = this.rootFolder.uri.length

const str = doc.uri.slice(head, head + 10).replace(/\//g, '-')

// let date = new Date(str + 'Z') // GMT - but fails in FF - invalid format :-(

const date = new Date(str) // not explicitly UTC but is assumed so in spec

// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/parse

debug.log('Date for ' + doc + ':' + date.toISOString())

return date

}

async loadPrevious (date, backwards) {

const thisDateFolder = this

async function previousPeriod (file, level) {

function younger (x) {

if (backwards ? x.uri >= file.uri : x.uri <= file.uri) return false // later than we want or same -- looking for different

return true

}

function suitable (x) {

const tail = x.uri

.slice(0, -1)

.split('/')

.slice(-1)[0]

if (!'0123456789'.includes(tail[0])) return false // not numeric

return true

}

async function lastNonEmpty (siblings) {

siblings = siblings.filter(suitable)

siblings.sort() // chronological order

if (!backwards) siblings.reverse()

if (level !== 3) return siblings.pop() // only length chck final leverl

while (siblings.length) {

const folder = siblings.pop()

const leafDocument = store.sym(folder.uri + thisDateFolder.leafFileName)

await store.fetcher.load(leafDocument)

// files can have seealso links. skip ones with no leafObjects with a date

if (

store.statementsMatching(null, ns.dct('created'), null, leafDocument)

.length > 0

) {

return folder

}

}

return null

}

// debug.log(' previousPeriod level' + level + ' file ' + file)

const parent = file.dir()

try {

await store.fetcher.load(parent)

let siblings = store.each(parent, ns.ldp('contains'))

siblings = siblings.filter(younger)

const folder = await lastNonEmpty(siblings)

if (folder) return folder

} catch (err) {

if (err.response && err.response.status && err.response.status === 404) {

debug.log('Error 404 for chat parent file ' + parent)

} else {

debug.log('*** Error NON 404 for chat parent file ' + parent)

// statusTR.appendChild(widgets.errorMessageBlock(dom, err, 'pink'))

throw (new Error(`*** ${err.message} for chat folder ${parent}`))

}

}

if (level === 0) return null // 3:day, 2:month, 1: year 0: no

const uncle = await previousPeriod(parent, level - 1)

if (!uncle) return null // reached first ever

await store.fetcher.load(uncle)

const cousins = store.each(uncle, ns.ldp('contains'))

const result = await lastNonEmpty(cousins)

return result

} // previousPeriod

const folder = this.leafDocumentFromDate(date).dir()

const found = await previousPeriod(folder, 3)

if (found) {

const doc = store.sym(found.uri + this.leafFileName)

return this.dateFromLeafDocument(doc)

}

return null

} // loadPrevious

async firstLeaf (backwards) {

// backwards -> last leafObject

const folderStore = $rdf.graph()

const folderFetcher = new $rdf.Fetcher(folderStore)

async function earliestSubfolder (parent) {

function suitable (x) {

const tail = x.uri

.slice(0, -1)

.split('/')

.slice(-1)[0]

if (!'0123456789'.includes(tail[0])) return false // not numeric

return true

}

debug.log(' parent ' + parent)

delete folderFetcher.requested[parent.uri]

// try {

await folderFetcher.load(parent, { force: true }) // Force fetch as will have changed

// }catch (err) {

// }

let kids = folderStore.each(parent, ns.ldp('contains'))

kids = kids.filter(suitable)

if (kids.length === 0) {

throw new Error(' @@@ No children to parent2 ' + parent)

}

kids.sort()

if (backwards) kids.reverse()

return kids[0]

}

const y = await earliestSubfolder(this.root.dir())

const month = await earliestSubfolder(y)

const d = await earliestSubfolder(month)

const leafDocument = $rdf.sym(d.uri + 'chat.ttl')

await folderFetcher.load(leafDocument)

const leafObjects = folderStore.each(

this.root,

this.membershipProperty,

null,

leafDocument

)

if (leafObjects.length === 0) {

const msg =

' INCONSISTENCY -- no chat leafObject in file ' + leafDocument

debug.trace(msg)

throw new Error(msg)

}

const sortMe = leafObjects.map(leafObject => [

folderStore.any(leafObject, ns.dct('created')),

leafObject

])

sortMe.sort()

if (backwards) sortMe.reverse()

debug.log(

(backwards ? 'Latest' : 'Earliest') + ' leafObject is ' + sortMe[0][1]

)

return sortMe[0][1]

} // firstleafObject

} // class