async function count(fen) {
    let counter = {
        black: {
            queens: 1,
            pawns: 8,
            bishops: 2,
            rooks: 2,
            knights: 2,
            kings: 1
        },
        white: {
            queens: 1,
            pawns: 8,
            bishops: 2,
            rooks: 2,
            knights: 2,
            kings: 1
        }
    };

    const lines = fen.split(' ')[0].split('/');
    lines.forEach((line) => {
        line.split('').forEach((letter) => {
            const key = ['p', 'n', 'q', 'b', 'r', 'k'].includes(letter) ? 'black' : 'white';
            const cors = {
                p: 'pawns',
                b: 'bishops',
                r: 'rooks',
                n: 'knights',
                q: 'queens',
                k: 'kings'
            };

            if (!cors[letter.toLowerCase()]) return;
            counter[key][cors[letter.toLowerCase()]] = counter[key][cors[letter.toLowerCase()]] - 1;
        })
    });
    return counter
}

async function avatarRound(data){
    return new Promise(async(resolve, reject) => {
        try {
            const canvas = createCanvas(250, 250)
            const ctx = canvas.getContext('2d')

            let img = await loadImage(data)
            
            ctx.beginPath()
            ctx.roundRect(0, 0, 200, 200, 20)
            ctx.stroke()
            ctx.clip()

            ctx.drawImage(img, 0, 0, 200, 200)

            await canvas.toDataURL('image/png', (err, data) => {
                if(err){
                    console.log(err)
                    reject(err);
                }
                resolve(data)
            })
        }catch(err){
            reject(err)
        }
    })
}

async function createBoard(data){

    return new Promise(async(resolve, reject) => {
        try{
            const imageGenerator = new ChessImageGenerator({
                size: 640,
                light: '#ba6a43',
                dark: '#9f2425',
                style: 'merida'
            })
        
            imageGenerator.loadFEN(data)

            resolve(await imageGenerator.generateBuffer())

        }catch(err){
            reject(err);
        }
    })
}

async function redifMatch(data, white, black, result){
    return new Promise(async(resolve, reject) => {
        try{
            const canvas = createCanvas(840, 1180)
            const ctx = canvas.getContext('2d')

            const encoder = new gifencoder(canvas.width, canvas.height)

            encoder.start()
            encoder.setRepeat(-1)
            encoder.setDelay(500)
            encoder.setQuality(10)

            ctx.fillStyle = '#202225'
            
            ctx.beginPath()
            ctx.roundRect(0, 0, canvas.width, canvas.height)
            ctx.stroke()
            ctx.fill()

            ctx.fillStyle = '#2f3136'

            ctx.beginPath()
            ctx.roundRect(100, 100, 640, 180, 20)
            ctx.stroke()
            ctx.fill()

            ctx.beginPath()
            ctx.roundRect(100, 920, 640, 180, 20)
            ctx.stroke()
            ctx.fill()

            let whiteImage = await loadImage(await avatarRound(white.avatar))
            let blackImage = await loadImage(await avatarRound(black.avatar))

            ctx.drawImage(whiteImage, 100, 920, 220, 220)
            ctx.drawImage(blackImage, 100, 100, 220, 220)

            ctx.fillStyle = '#FFF'
            ctx.font = 'bold 40px Sans-serif'
            ctx.textAlign = 'left'
            ctx.fillText(white.username, 320, 1000)
            ctx.fillText(black.username, 320, 180)

            let counter;

            let chess = new Chess()

            for(let element of data.split(' ')){
                if(element.includes('.') == false && element.includes('0-1') == false && element.includes('1-0') == false && element.includes('0-0') == false) chess.move(element)
                if(element.includes('.') == false && element.includes('0-1') == false && element.includes('1-0') == false && element.includes('0-0') == false) counter = await count(await chess.fen())
                
                //let img = await loadImage('https://chess-image-generator.vercel.app/api?moves=' + encodeURI(before) + '&playerColor=white')
                let img = await loadImage(await createBoard(await chess.fen()))
                ctx.drawImage(img, 100, 280, img.width, img.height)

                encoder.addFrame(ctx)

                if(counter !== undefined){
                    for(let color of [{name: 'white', where: 220}, {name: 'black', where: 1035}]){
                        for(let pawn of [{name: 'pawns', where: 300}, {name: 'bishops', where: 400}, {name: 'knights', where: 460}, {name: 'rooks', where: 520}, {name: 'queens', where: 580}]){
                            let img = await loadImage('./src/img/pawn/' + color['name'].slice(0, 1) + pawn['name'].slice(0, 1) + ".png")
    
                            for(let i = 0; i < counter[color.name][pawn.name]; i++){
                                ctx.drawImage(img, pawn['where'] + (i * 10), color['where'], 50, 50)
                            }
                        }
                    }
                }
            }

            for(let i = 0; i < 10; i++){
                encoder.addFrame(ctx)
            }

            encoder.finish()
            
            const buffer = encoder.out.getData()

            resolve(buffer)
        }catch(err){
            reject(err)
        }
    })
}