import DOMPurify from 'isomorphic-dompurify';
import showdown from 'showdown';
import { Marked } from 'marked';

import { DataBase, type Database, type character, type groupChat } from './storage/database';
import { getFileSrc } from './storage/globalApi';
import { processScript, processScriptFull } from './process/scripts';
import { get } from 'svelte/store';
import css from '@adobe/css-tools'
import { selectedCharID } from './stores';
import { calcString } from './process/infunctions';
import { findCharacterbyId } from './util';

const convertora = new showdown.Converter({
    simpleLineBreaks: true,
    strikethrough: true,
    tables: true
})

const mconverted = new Marked({
    gfm: true,
    breaks: true,
    silent: true,
    tokenizer: {

    }
})

const safeConvertor = new showdown.Converter({
    simpleLineBreaks: true,
    strikethrough: true,
    tables: true,
    backslashEscapesHTMLTags: true
})



DOMPurify.addHook("uponSanitizeElement", (node: HTMLElement, data) => {
    if (data.tagName === "iframe") {
       const src = node.getAttribute("src") || "";
       if (!src.startsWith("https://www.youtube.com/embed/")) {
          return node.parentNode.removeChild(node);
       }
    }
});

DOMPurify.addHook("uponSanitizeAttribute", (node, data) => {
    if(data.attrName === 'style'){
        data.attrValue = data.attrValue.replace(/(absolute)|(z-index)|(fixed)/g, '')
    }
    if(data.attrName === 'class'){
        data.attrValue = data.attrValue.split(' ').map((v) => {
            return "x-risu-" + v
        }).join(' ')
    }
})

async function parseAdditionalAssets(data:string, char:character, mode:'normal'|'back'){
    if(char.additionalAssets){
        for(const asset of char.additionalAssets){
            const assetPath = await getFileSrc(asset[1])
            data = data.replaceAll(`{{raw::${asset[0]}}}`, assetPath).
                    replaceAll(`{{img::${asset[0]}}}`,`<img src="${assetPath}" alt="${asset[0]}"/>`)
                    .replaceAll(`{{video::${asset[0]}}}`,`<video controls autoplay loop><source src="${assetPath}" type="video/mp4"></video>`)
                    .replaceAll(`{{audio::${asset[0]}}}`,`<audio controls autoplay loop><source src="${assetPath}" type="audio/mpeg"></audio>`)
            if(mode === 'back'){
                data = data.replaceAll(`{{bg::${asset[0]}}}`, `<div style="width:100%;height:100%;background: linear-gradient(rgba(0, 0, 0, 0.8), rgba(0, 0, 0, 0.8)),url(${assetPath}); background-size: cover;"></div>`)
            }
        }
    }

    return data
}

export async function ParseMarkdown(data:string, char:(character | groupChat) = null, mode:'normal'|'back' = 'normal', chatID=-1) {
    let firstParsed = ''
    const orgDat = data
    if(char && char.type !== 'group'){
        data = await parseAdditionalAssets(data, char, mode)
        firstParsed = data
    }
    if(char){
        data = processScriptFull(char, data, 'editdisplay', chatID).data
    }
    if(firstParsed !== data && char && char.type !== 'group'){
        data = await parseAdditionalAssets(data, char, mode)
    }
    return decodeStyle(DOMPurify.sanitize(mconverted.parse(encodeStyle(data)), {
        ADD_TAGS: ["iframe", "style", "risu-style"],
        ADD_ATTR: ["allow", "allowfullscreen", "frameborder", "scrolling"],
        FORBID_ATTR: ["href"]
    }))
}

export function parseMarkdownSafe(data:string) {
    return DOMPurify.sanitize(safeConvertor.makeHtml(data), {
        FORBID_TAGS: ["a", "style"],
        FORBID_ATTR: ["style", "href", "class"]
    })
}


const styleRegex = /\<style\>(.+?)\<\/style\>/gms
function encodeStyle(txt:string){
    return txt.replaceAll(styleRegex, (f, c1) => {
        return "<risu-style>" + Buffer.from(c1).toString('hex') + "</risu-style>"
    })
}
const styleDecodeRegex = /\<risu-style\>(.+?)\<\/risu-style\>/gms

function decodeStyle(text:string){

    return text.replaceAll(styleDecodeRegex, (full, txt:string) => {
        try {
            const ast = css.parse(Buffer.from(txt, 'hex').toString('utf-8'))
            const rules = ast?.stylesheet?.rules
            if(rules){
                for(const rule of rules){
                    if(rule.selectors){
                        for(let i=0;i<rule.selectors.length;i++){
                            let slt:string = rule.selectors[i]
                            let selectors = slt.split(' ').map((v) => {
                                if(v.startsWith('.')){
                                    return ".x-risu-" + v.substring(1)
                                }
                                return v
                            }).join(' ')

                            rule.selectors[i] = ".chattext " + selectors
                        }
                    }
                }
            }
            return `<style>${css.stringify(ast)}</style>`

        } catch (error) {
            return `CSS ERROR: ${error}`;
        }
    })
}

export async function hasher(data:Uint8Array){
    return Buffer.from(await crypto.subtle.digest("SHA-256", data)).toString('hex');
}

export async function convertImage(data:Uint8Array) {
    if(!get(DataBase).imageCompression){
        return data
    }
    const type = checkImageType(data)
    if(type !== 'Unknown' && type !== 'WEBP' && type !== 'AVIF'){
        if(type === 'PNG' && isAPNG(data)){
            return data
        }
        return await resizeAndConvert(data)
    }
    return data
}

async function resizeAndConvert(imageData: Uint8Array): Promise<Buffer> {
    return new Promise((resolve, reject) => {
        const base64Image = 'data:image/png;base64,' + Buffer.from(imageData).toString('base64');
        const image = new Image();
        image.onload = () => {
            URL.revokeObjectURL(base64Image);

            // Create a canvas
            const canvas = document.createElement('canvas');
            const context = canvas.getContext('2d');
            if (!context) {
                throw new Error('Unable to get 2D context');
            }

            // Compute the new dimensions while maintaining aspect ratio
            let { width, height } = image;
            if (width > 3000 || height > 3000) {
                const aspectRatio = width / height;
                if (width > height) {
                    width = 3000;
                    height = Math.round(width / aspectRatio);
                } else {
                    height = 3000;
                    width = Math.round(height * aspectRatio);
                }
            }

            // Resize and draw the image to the canvas
            canvas.width = width;
            canvas.height = height;
            context.drawImage(image, 0, 0, width, height);

            // Try to convert to WebP
            let base64 = canvas.toDataURL('image/webp', 90);

            // If WebP is not supported, convert to JPEG
            if (base64.indexOf('data:image/webp') != 0) {
                base64 = canvas.toDataURL('image/jpeg', 90);
            }

            // Convert it to Uint8Array
            const array = Buffer.from(base64.split(',')[1], 'base64');
            resolve(array);
        };
        image.src = base64Image;
    });
}

type ImageType = 'JPEG' | 'PNG' | 'GIF' | 'BMP' | 'AVIF' | 'WEBP' | 'Unknown';

function checkImageType(arr:Uint8Array):ImageType {
    const isJPEG = arr[0] === 0xFF && arr[1] === 0xD8 && arr[arr.length-2] === 0xFF && arr[arr.length-1] === 0xD9;
    const isPNG = arr[0] === 0x89 && arr[1] === 0x50 && arr[2] === 0x4E && arr[3] === 0x47 && arr[4] === 0x0D && arr[5] === 0x0A && arr[6] === 0x1A && arr[7] === 0x0A;
    const isGIF = arr[0] === 0x47 && arr[1] === 0x49 && arr[2] === 0x46 && arr[3] === 0x38 && (arr[4] === 0x37 || arr[4] === 0x39) && arr[5] === 0x61;
    const isBMP = arr[0] === 0x42 && arr[1] === 0x4D;
    const isAVIF = arr[4] === 0x66 && arr[5] === 0x74 && arr[6] === 0x79 && arr[7] === 0x70 && arr[8] === 0x61 && arr[9] === 0x76 && arr[10] === 0x69 && arr[11] === 0x66;
    const isWEBP = arr[0] === 0x52 && arr[1] === 0x49 && arr[2] === 0x46 && arr[3] === 0x46 && arr[8] === 0x57 && arr[9] === 0x45 && arr[10] === 0x42 && arr[11] === 0x50;

    if (isJPEG) return "JPEG";
    if (isPNG) return "PNG";
    if (isGIF) return "GIF";
    if (isBMP) return "BMP";
    if (isAVIF) return "AVIF";
    if (isWEBP) return "WEBP";
    return "Unknown";
}

function isAPNG(pngData: Uint8Array): boolean {
    const pngSignature = [0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A];
    const acTL = [0x61, 0x63, 0x54, 0x4C];
  
    if (!pngData.slice(0, pngSignature.length).every((v, i) => v === pngSignature[i])) {
      throw new Error('Invalid PNG data');
    }
  
    for (let i = pngSignature.length; i < pngData.length - 12; i += 4) {
      if (pngData.slice(i + 4, i + 8).every((v, j) => v === acTL[j])) {
        return true;
      }
    }
    return false;
}

function wppParser(data:string){
    const lines = data.split('\n');
    let characterDetails:{[key:string]:string[]} = {};

    lines.forEach(line => {

        // Check for "{" and "}" indicator of object start and end
        if(line.includes('{')) return;
        if(line.includes('}')) return;

        // Extract key and value within brackets
        let keyBracketStartIndex = line.indexOf('(');
        let keyBracketEndIndex = line.indexOf(')');
        
       if(keyBracketStartIndex === -1 || keyBracketEndIndex === -1) 
            throw new Error(`Invalid syntax ${line}`);
        
       let key = line.substring(0, keyBracketStartIndex).trim();

         // Validate Key    
         if(!key) throw new Error(`Missing Key in ${line}`);

      const valueArray=line.substring(keyBracketStartIndex + 1, keyBracketEndIndex)
          .split(',')
          .map(str => str.trim());
      
      // Validate Values
      for(let i=0;i<valueArray.length ;i++){
           if(!valueArray[i])
               throw new Error(`Empty Value in ${line}`);
              
     }
      characterDetails[key] = valueArray;
   });

   return characterDetails;
}


const rgx = /(?:{{|<)(.+?)(?:}}|>)/gm
export function risuChatParser(da:string, arg:{
    chatID?:number
    db?:Database
    chara?:string|character|groupChat
    rmVar?:boolean
} = {}):string{
    const chatID = arg.chatID ?? -1
    const db = arg.db ?? get(DataBase)
    const aChara = arg.chara
    let chara:character|string = null

    if(aChara){
        if(typeof(aChara) !== 'string' && aChara.type === 'group'){
            const gc = findCharacterbyId(aChara.chats[aChara.chatPage].message.at(-1).saying ?? '')
            if(gc.name !== 'Unknown Character'){
                chara = gc
            }
        }
        else{
            chara = aChara
        }
    }
    const matcher = (p1:string) => {
        const lowerCased = p1.toLocaleLowerCase()
        switch(lowerCased){
            case 'previous_char_chat':{
                if(chatID !== -1){
                    const selchar = db.characters[get(selectedCharID)]
                    const chat = selchar.chats[selchar.chatPage]
                    let pointer = chatID - 1
                    while(pointer >= 0){
                        if(chat.message[pointer].role === 'char'){
                            return chat.message[pointer].data
                        }
                        pointer--
                    }
                    return selchar.firstMsgIndex === -1 ? selchar.firstMessage : selchar.alternateGreetings[selchar.firstMsgIndex]
                }
                return ''
            }
            case 'previous_user_chat':{
                if(chatID !== -1){
                    const selchar = db.characters[get(selectedCharID)]
                    const chat = selchar.chats[selchar.chatPage]
                    let pointer = chatID - 1
                    while(pointer >= 0){
                        if(chat.message[pointer].role === 'user'){
                            return chat.message[pointer].data
                        }
                        pointer--
                    }
                    return selchar.firstMsgIndex === -1 ? selchar.firstMessage : selchar.alternateGreetings[selchar.firstMsgIndex]
                }
                return ''
            }
            case 'char':
            case 'bot':{
                let selectedChar = get(selectedCharID)
                let currentChar = db.characters[selectedChar]
                if(currentChar.type !== 'group'){
                    return currentChar.name
                }
                if(chara){
                    if(typeof(chara) === 'string'){
                        return chara
                    }
                    else{
                        return chara.name
                    }
                }
                return currentChar.name
            }
            case 'user':{
                return db.username
            }
            case 'personality':
            case 'char_persona':{
                const argChara = chara
                const achara = (argChara && typeof(argChara) !== 'string') ? argChara : (db.characters[get(selectedCharID)])
                if(achara.type === 'group'){
                    return ""
                }
                return achara.personality
            }
            case 'description':
            case 'char_desc':{
                const argChara = chara
                const achara = (argChara && typeof(argChara) !== 'string') ? argChara : (db.characters[get(selectedCharID)])
                if(achara.type === 'group'){
                    return ""
                }
                return achara.desc
            }
            case 'scenario':{
                const argChara = chara
                const achara = (argChara && typeof(argChara) !== 'string') ? argChara : (db.characters[get(selectedCharID)])
                if(achara.type === 'group'){
                    return ""
                }
                return achara.scenario
            }
            case 'example_dialogue':
            case 'example_message':{
                const argChara = chara
                const achara = (argChara && typeof(argChara) !== 'string') ? argChara : (db.characters[get(selectedCharID)])
                if(achara.type === 'group'){
                    return ""
                }
                return achara.exampleMessage
            }
            case 'persona':
            case 'user_persona':{
                return db.personaPrompt
            }
            case 'main_prompt':
            case 'system_prompt':{
                return db.mainPrompt
            }
            case 'lorebook':
            case 'world_info':{
                const argChara = chara
                const achara = (argChara && typeof(argChara) !== 'string') ? argChara : (db.characters[get(selectedCharID)])
                const selchar = db.characters[get(selectedCharID)]
                const chat = selchar.chats[selchar.chatPage]
                const characterLore = (achara.type === 'group') ? [] : (achara.globalLore ?? [])
                const chatLore = chat.localLore ?? []
                const globalLore = db.loreBook[db.loreBookPage]?.data ?? []
                const fullLore = characterLore.concat(chatLore.concat(globalLore))
                return fullLore.map((f) => {
                    return JSON.stringify(f)
                }).join("§\n")
            }
            case 'history':
            case 'messages':{
                const selchar = db.characters[get(selectedCharID)]
                const chat = selchar.chats[selchar.chatPage]
                return chat.message.map((f) => {
                    return JSON.stringify(f)
                }).join("§\n")
            }
            case 'ujb':
            case 'global_note':
            case 'system_note':{
                return db.globalNote
            }
            case 'chat_index':{
                return chatID.toString() 
            }
            case 'blank':
            case 'none':{
                return ''
            }
        }
        const arra = p1.split("::")
        if(arra.length > 1){
            const v = arra[1]
            switch(arra[0]){
                case 'getvar':{
                    const d =getVarChat(chatID)
                    return d[v] ?? "[Null]" 
                }
                case 'calc':{
                    return calcString(v).toString()
                }
                case 'addvar':
                case 'setvar':{
                    if(arg.rmVar){
                        return ''
                    }
                    break
                }
                case 'button':{
                    return `<button style="padding" x-risu-prompt="${arra[2]}">${arra[1]}</button>`
                }
                case 'risu':{
                    return `<img src="/logo2.png" style="height:${v || 45}px;width:${v || 45}px" />`
                }
            }
        }
        if(p1.startsWith('random')){
            if(p1.startsWith('random::')){
                const randomIndex = Math.floor(Math.random() * (arra.length - 1)) + 1
                return arra[randomIndex]
            }
            else{
                const arr = p1.split(/\:|\,/g)
                const randomIndex = Math.floor(Math.random() * (arr.length - 1)) + 1
                return arr[randomIndex]
            }
        }
        return null
    }
    
    let pointer = 0;
    let nested:string[] = [""]
    let pf = performance.now()
    let v = new Uint8Array(255)
    while(pointer < da.length){
        switch(da[pointer]){
            case '{':{
                if(da[pointer + 1] !== '{'){
                    nested[0] += da[pointer]
                    break
                }
                pointer++
                nested.unshift('')
                v[nested.length] = 1
                break
            }
            case '<':{
                nested.unshift('')
                v[nested.length] = 2
                break
            }
            case '}':{
                if(da[pointer + 1] !== '}' || nested.length === 1 || v[nested.length] !== 1){
                    nested[0] += da[pointer]
                    break
                }
                pointer++
                const dat = nested.shift()
                const mc = matcher(dat)
                nested[0] += mc ?? `{{${dat}}}`
                break
            }
            case '>':{
                if(nested.length === 1 || v[nested.length] !== 2){
                    break
                }
                const dat = nested.shift()
                const mc = matcher(dat)
                nested[0] += mc ?? `<${dat}>`
                break
            }
            default:{
                nested[0] += da[pointer]
                break
            }
        }
        pointer++
    }
    if(nested.length === 1){
        return nested[0]
    }
    let result = ''
    while(nested.length > 1){
        let dat = (v[nested.length] === 1) ? '{{' : "<"
        dat += nested.shift()
        result = dat + result
    }
    return nested[0] + result
}

function getVarChat(targetIndex = -1){
    const db = get(DataBase)
    const selchar = db.characters[get(selectedCharID)]
    const chat = selchar.chats[selchar.chatPage]
    let i =0;
    if(targetIndex === -1 || targetIndex >= chat.message.length){
        targetIndex = chat.message.length - 1
    }
    let vars:{[key:string]:string} = {}
    let rules:{
        key:string
        rule:string
        arg:string
    }[] = []
    const fm = selchar.firstMsgIndex === -1 ? selchar.firstMessage : selchar.alternateGreetings[selchar.firstMsgIndex]
    const rg = /(\{\{setvar::(.+?)::(.+?)\}\})/gu
    const rg2 = /(\{\{addvar::(.+?)::(.+?)\}\})/gu
    const rg3 = /(\{\{varrule_(.+?)::(.+?)::(.+?)\}\})/gu
    function process(text:string){
        const m = text.matchAll(rg)
        for(const a of m){
            if(a.length === 4){
                vars[a[2]] = a[3]
            }
        }
        const m2 = text.matchAll(rg2)
        for(const a of m2){
            if(a.length === 4){
                vars[a[2]] = (parseInt(vars[a[2]]) + parseInt(a[3])).toString()
            }
        }
        const m3 = text.matchAll(rg3)
        for(const a of m3){
            if(a.length === 5){
                rules.push({
                    key: a[3],
                    rule: a[2],
                    arg: a[4]
                })
            }
        }
    }
    process(fm)
    while( i <= targetIndex ){
        process(chat.message[i].data)
        i += 1
    }

    for(const rule of rules){
        if(vars[rule.key] === undefined){
            continue
        }
        switch(rule.rule){
            case "max":{
                if(parseInt(vars[rule.key]) > parseInt(rule.arg)){
                    vars[rule.key] = rule.arg
                }
                break
            }
            case "min":{
                if(parseInt(vars[rule.key]) < parseInt(rule.arg)){
                    vars[rule.key] = rule.arg
                }
                break
            }
            case 'overflow':{
                const exArg = rule.arg.split(":")
                let rv = parseInt(vars[rule.key])
                const val = parseInt(exArg[0])
                const tg = exArg[1]

                if(isNaN(val) || isNaN(rv)){
                    break
                }

                vars[tg] = (Math.floor(rv / val)).toString()
                vars[rule.key] = (Math.floor(rv % val)).toString()
            }
        }
    }
    return vars
}