const fs = require('fs')
const config = require('./config')
const random = require('./random')
const classes = require('./classes')
const mock = require('./mock')

let batchCount = 1 // Counter to track how many things we've generated
let extraProfilesToGenerate = 1
let extraProfileCount = 0 // Counter to track how many EXTRA profiles we've generated
let generatedResponseCount = 0 // Counter to track every response generated

// Values for responsess as strings
const possibleResponses = {
    not_important: null,
    some_what_important: null,
    important: null,
    very_important: null,
    extremely_important: null,
    mandatory: null,
}
for (let i = 0; i < Object.keys(possibleResponses).length; i++) {
    const key = Object.keys(possibleResponses)[i]
    possibleResponses[key] = config.scoreVals[i].toString()
}

/**
 * Our initial file setup
 */
const write = async (batchNum, outputDataObject) => {
    const filename = `_batch_${batchNum}.js`
    await fs.writeFile(`${config.mockOutputPath}/${filename}`, '', () => {})
    fs.appendFile(
        `${config.mockOutputPath}/${filename}`,
        config.header +
            'module.exports = ' +
            JSON.stringify(outputDataObject, null, '  '),
        err => {
            if (err) {
                console.error(err)
                return
            }
        },
    )
}

// Helper functions
const generate = (classObj, amount, meta) => {
    const instances = []
    for (let i = 0; i < amount; i++) {
        let startFrom = meta?.starting ? meta.starting - config.batchSize : 0
        instances.push(new classObj(i + startFrom + 1, meta))
    }
    return instances
}

console.log('\nStarting...\n---')

/**
 * Generate Users
 */
const generateUsers = () => {
    let users = generate(classes.User, config.batchSize, {
        starting: config.batchSize * batchCount,
    })
    users.forEach(user => {
        user.is_poster = random.number(100) > config.percentageOfSeekers ? 1 : 0
        if (user.is_poster) {
            extraProfilesToGenerate = extraProfilesToGenerate + random.number(2)
        }
        user.user_name = random.name() + ' ' + random.name()
        user.user_email = random.email()
    })
    console.log('COMPLETED: Generated Users...')
    return users
}

/**
 * Generate Profiles
 */
const generateProfiles = jobPosterIds => {
    let profiles = generate(classes.Profile, config.batchSize, {
        starting: config.batchSize * batchCount,
        profile_id: extraProfileCount,
    })

    // Generate extra job posting profiles
    // attributed to random user.is_poster === true
    // TODO: Clean this up. Hard to read...
    if (extraProfilesToGenerate > 0) {
        let extras = []
        for (let l = 0; l < extraProfilesToGenerate; l++) {
            const generatedExtraProfiles = generate(classes.Profile, 1, {
                user_id:
                    jobPosterIds.length > 1
                        ? random.valFrom(jobPosterIds)
                        : jobPosterIds[0],
                profile_id:
                    config.batchSize * batchCount + extraProfileCount + l,
            })
            extras = [...extras, ...generatedExtraProfiles]
        }
        extras.forEach(profile => {
            profiles.push(profile)
            extraProfileCount++
        })
    }
    console.log('COMPLETED: Generated Profiles...')
    return profiles
}

/**
 * Generate Responses
 */
const generateResponses = profiles => {
    // Generate responses first, before filling in details
    let responses = generate(
        classes.Response,
        (config.batchSize + extraProfilesToGenerate) *
            mock.response_keys.length,
        { starting: generatedResponseCount + config.batchSize },
    )
    profiles.forEach((profile, i) => {
        const startingIndex = i * mock.response_keys.length
        for (let k = 0; k < mock.response_keys.length; k++) {
            const resToEdit = responses[startingIndex + k]
            resToEdit.response_key_id = k + 1
            resToEdit.profile_id = profile.profile_id

            if (resToEdit.response_key_id < config.zipcodeKey) {
                resToEdit.val = random.valFrom(Object.values(possibleResponses))
            } else if (resToEdit.response_key_id == config.zipcodeKey) {
                resToEdit.val = random.valFrom(config.possibleZipcodes)
            } else {
                switch (resToEdit.response_key_id) {
                    case config.mediaKey:
                        resToEdit.val = random.media()
                        break
                    case config.langKey:
                        resToEdit.val = random.language()
                        break
                    case config.durationKey:
                        resToEdit.val = random.duration()
                        break
                    case config.presenceKey:
                        resToEdit.val = random.location()
                        break
                    case config.blurbKey:
                        resToEdit.val = random.blurb()
                        break
                }
            }
        }
    })
    generatedResponseCount = generatedResponseCount + responses.length
    console.log('COMPLETED: Generated Responses...')
    return responses
}

/**
 * Our main generator loop
 */
for (
    let batch = config.batchSize;
    batch <= config.total;
    batch += config.batchSize
) {
    const users = generateUsers()

    let jobPosterIds = users
        .filter(user => user.is_poster > 0)
        .map(user => user.user_id)
    // Guarantee ONE job poster
    if (!jobPosterIds.length) {
        random.valFrom(users).is_poster = 1
        jobPosterIds = users
            .filter(user => user.is_poster > 0)
            .map(user => user.user_id)
    }

    const profiles = generateProfiles(jobPosterIds)
    const responses = generateResponses(profiles)

    write(config.batchSize * batchCount, { users, profiles, responses })
    batchCount++
}

console.log('---\nFINISHED...\n===\n')