import { randomItem, ordinalSuffix } from './utils.mjs'
import Genome from './genome.mjs'
import Nucleotide from './nucleotide.mjs'
import Die from './die.mjs'
import GenomeList from './genome-list.mjs'
import NucleotideSelector from './nucleotide-selector.mjs'
import Error from './error.mjs'

class CloneNucleotide {
    constructor(rules) {
        this.rules = rules

        this.id = 'clone-nucleotide'
        this._boundClickHandler = this.clickHandler.bind(this)
    }

    enter() {
        this.rules.cloneButton.addEventListener('click',
                                                this._boundClickHandler)
        this.rules.cloneButton.disabled = false
    }

    exit() {
        this.rules.cloneButton.removeEventListener('click',
                                                   this._boundClickHandler)
        this.rules.cloneButton.disabled = true
    }

    clickHandler(evt) {
        const genome = this.rules.currentGenome.clone()
        this.rules.genomeList.push(genome)
        this.rules.next(new RollForNucleotide(this.rules))
    }
}

class RollForNucleotide {
    constructor(rules) {
        this.rules = rules

        this.id = 'roll-for-nucleotide'
    }

    enter() {
        this.rules.die.value = '--'
        this.rules.die.onChanged = this.handleDieRoll.bind(this)
        this.rules.die.enable()
    }

    exit() {
        this.rules.die.disable()
        this.rules.die.onChanged = undefined
    }

    handleDieRoll() {
        if (this.rules.die.value > Genome.size) {
            this.rules.iterations--
            if (this.rules.isLastIteration) {
                this.rules.next(new DoNothing(this.rules))
            } else {
                this.rules.next(new CloneNucleotide(this.rules))
            }
        } else {
            this.rules.next(new NucleotideSelect(this.rules))
        }
    }
}

class NucleotideSelect {
    constructor(rules) {
        this.rules = rules

        this.id = 'nucleotide-select'
    }

    enter() {
        this.want = this.rules.die.value
        this.rules.instructions.querySelector('#select-number').innerHTML =
            `${this.want}<sup>${ordinalSuffix(this.want)}</sup>`

        this.rules.currentGenome.onSelectionChanged =
            this.handleSelectionChanged.bind(this)
        this.rules.currentGenome.unlock()
    }

    exit() {
        this.rules.currentGenome.lock()
        this.rules.currentGenome.onSelectionChanged = undefined;
    }

    handleSelectionChanged(nucleotide, i) {
        i++;
        if (i != this.rules.die.value) {
            this.rules.error.innerHTML =
                `You selected the ${i}<sup>${ordinalSuffix(i)}</sup> nucleotide. Please select the ${this.want}<sup>${ordinalSuffix(this.want)}</sup> one.`
            this.rules.next(new ShowError(this.rules, this))
            return
        }
        this.rules.next(new RollForMutation(this.rules))
    }
}

class RollForMutation {
    constructor(rules) {
        this.rules = rules

        this.id = 'roll-for-mutation'
    }

    enter() {
        this.rules.die.value = '--'
        this.rules.die.onChanged = this.handleDieRoll.bind(this)
        this.rules.die.enable()
    }

    exit() {
        this.rules.die.disable()
        this.rules.die.onChanged = undefined
    }

    handleDieRoll() {
        this.rules.next(new PerformMutation(this.rules))
    }
}

class PerformMutation {
    constructor(rules) {
        this.rules = rules

        this.id = 'perform-mutation'
    }

    enter() {
        const selector = this.rules.nucleotideSelector
        selector.onItemSelected = this.handleItemSelected.bind(this)
        selector.attach(this.selectedNucleotide)
    }

    exit() {
        this.rules.nucleotideSelector.detach()
    }

    validMutation(from, to) {
        return to == this.expectedMutation[from]
    }

    get expectedMutation() {
        if (this.rules.die.value <= 14) {
            return Nucleotide.transition
        } else if (this.rules.die.value <= 17) {
            return Nucleotide.complementingTransversion
        } else {
            return Nucleotide.defaultTransversion
        }
    }

    get selectedNucleotide() {
        return this.rules.currentGenome.selectedNucleotide
    }

    get errorTransitionHTML() {
        return `Select the base that corresponds to a <em>transition</em> of ${this.selectedNucleotide.value}.`
    }
    get errorComplementingTransversionHTML() {
        return `Select the base that corresponds to a <em>complementing transversion</em> of ${this.selectedNucleotide.value}.`
    }
    get errorDefaultTransversionHTML() {
        return `Select the base that corresponds to the <em>other transversion</em> of ${this.selectedNucleotide.value}.`
    }

    get errorHTML() {
        if (this.expectedMutation == Nucleotide.transition) {
            return this.errorTransitionHTML
        } else if (this.expectedMutation == Nucleotide.complementingTransversion) {
            return this.errorComplementingTransversionHTML
        } else {
            return this.errorDefaultTransversionHTML
        }
    }

    handleItemSelected(base) {
        if (!this.validMutation(this.selectedNucleotide.value, base)) {
            this.rules.error.innerHTML = this.errorHTML
            this.rules.next(new ShowError(this.rules, this))
            return
        }

        this.selectedNucleotide.value = base
        this.rules.iterations--
        if (this.rules.isLastIteration) {
            this.rules.next(new DoNothing(this.rules))
        } else {
            this.rules.next(new CloneNucleotide(this.rules))
        }
    }
}

class DoNothing {
    constructor(rules) {
        this.rules = rules

        this.id = 'print-results'
        this._boundClickHandler = this.clickHandler.bind(this)
    }

    enter() {
        this.rules.printButton.addEventListener('click', this._boundClickHandler)
        this.rules.printButton.disabled = false
    }

    exit() {
        this.rules.printButton.disabled = true
        this.rules.printButton.removeEventListener('click', this._boundClickHandler)
    }

    clickHandler() {
        window.print()
    }
}

class ShowError {
    constructor(rules, nextState) {
        this.rules = rules
        this.nextState = nextState

        this._boundClickHandler = this.clickHandler.bind(this)
    }

    enter() {
        this.rules.error.onClick = this._boundClickHandler
        this.rules.error.show()
    }

    exit() {
        this.rules.error.hide()
        this.rules.error.onClick = undefined
    }

    clickHandler() {
        this.rules.next(this.nextState)
    }
}

class Rules {
    constructor(die, instructions, genomeList, nucleotideSelector, cloneButton, remainingIterations, printButton, errors) {
        this.die = new Die(die)
        this.instructions = instructions
        this.genomeList = new GenomeList(genomeList)
        this.nucleotideSelector = new NucleotideSelector(nucleotideSelector)
        this.cloneButton = cloneButton
        this.remainingIterations = remainingIterations
        this.printButton = printButton
        this.error = new Error(errors)

        this.iterations = Rules.maxIterations
        this.cloneButton.disabled = true
        this.genomeList.push(new Genome(Rules.initialGenomeBases))

        if (false) {
            this._debugStartAtRollForMutation()
        } else if (false) {
            this._debugStartAtPerformMutation(4)
        } else if (false) {
            this._debugStartWithError()
        } else {
            this.currentState = new CloneNucleotide(this)
        }
        this.enterState()
    }

    get iterations() {
        return Number(this.remainingIterations.innerText)
    }

    set iterations(val) {
        this.remainingIterations.innerText = val
    }

    get isLastIteration() {
        return this.iterations == 0
    }

    _debugStartAtRollForMutation() {
        this.currentState = new RollForMutation(this)
        const nucleotide = this.currentGenome.nucleotides[2]
        this.currentGenome.selectedNucleotide = nucleotide
    }

    _debugStartAtPerformMutation(n) {
        [...Array(n)].forEach(i => {
            const n = randomItem(this.currentGenome.nucleotides)
            n.value = randomItem(Nucleotide.bases)
            this.currentGenome.selectedNucleotide = n
            const g = this.currentGenome.clone()
            window.g = g
            this.genomeList.push(g)
        })

        this.currentState = new PerformMutation(this)
        this.die.value = 15
        const nucleotide = this.currentGenome.nucleotides[15]
        this.currentGenome.selectedNucleotide = nucleotide
    }

    _debugStartWithError() {
        this.currentState = new ShowError(this, new CloneNucleotide(this))
        this.error.innerHTML = 'test an error'
    }

    get currentGenome() {
        return this.genomeList.last
    }

    showCurrent() {
        if (this.currentState.id === undefined) {
            return
        }
        const elt =
              this.instructions.querySelector(`#${this.currentState.id}`)
        elt.classList.add('current')
        elt.scrollIntoView(true)
    }

    hideCurrent() {
        if (this.currentState.id === undefined) {
            return
        }
        const elt =
              this.instructions.querySelector(`#${this.currentState.id}`)
        elt.classList.remove('current')
    }

    enterState() {
        this.currentState.enter()
        this.showCurrent()
    }

    exitState() {
        this.hideCurrent()
        this.currentState.exit()
    }

    next(nextState) {
        this.exitState()
        this.currentState = nextState
        this.enterState()
    }
}
Rules.maxIterations = 10
Rules.initialGenomeBases = [
    'G', 'C', 'A',
    'C', 'T', 'C',
    'G', 'G', 'A',
    'T', 'C', 'G',
    'A', 'A', 'T',
    'T', 'C', 'T'
]

export default Rules