import { Track } from "./tracks_table.mjs"
import { findLanguage, isLanguageAlias, flattenObj } from "./utils.mjs"

class Mismatch {
    constructor(track, key, value) {
        this.track = track
        this.key = key
        this.value = value
    }
}

export default class IntegrityManager {
    /**
     * 
     * @param {import('./editor.mjs').default} editor 
     */
    constructor(editor) {
        this.editor = editor
        this.mismatches = []
    }

    checkIntegrity() {
        for (const table of Object.values(this.editor.tables)) {
            this.checkTableIntegrity(table)
        }
        console.log(this.mismatches)
    }

    /**
     * 
     * @param {import('./tracks_table.mjs').default} table 
     */
    checkTableIntegrity(table) {
        for (const track of table.tracks) {
            this.checkTrackIntegrity(track)
        }
    }

    /**
     * 
     * @param {Track} track 
     */
    checkTrackIntegrity(track) {
        let fields = this.parseName(track.table.type, track.fields["name"])
        fields = flattenObj(fields)
        
        Object.entries(fields).map(([key, value]) => {
            let equal = track.fields[key] === value
            if (key === "language") {
                equal = isLanguageAlias(value, track.fields[key])
            }
            if (!equal) {
                this.addMismatchField(track, key, value)
                console.error(`Mismatch for field ${key}:\n- name: ${value}\n- track: ${track.fields[key]}`)
            } else {
                track.fields[key] = value
            }
        })
    }

    parseName(trackType, name) {
        const lower = name.toLowerCase()
        const parts = lower.split(/\b/)
        const fields = {flags: {}}
        switch (trackType) {
            case "subtitle":
                let forced = parts.includes("forced")
                let lang = findLanguage(lower)
                if (forced) {fields.flags.forced = forced}
                if (lang !== null) {fields.language = lang}
                let ad = parts.includes("sdh") || parts.includes("ad")
                if (ad) {fields.flags.hearing_impaired = ad}
                let original = parts.includes("vo")
                if (original) {fields.flags.original = original}
                break
        }
        return fields
    }

    addMismatchField(track, key, value) {
        this.mismatches.push(new Mismatch(track, key, value))
    }
}