#include <assert.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdio.h>
#include "picture.h"
#include "studio/geometry.h"
#include "studio/pdf.h"
#include "unreliableobjects.h"

static struct pdf paint(struct pdf pdf, const matrix composition)
{   
    struct picture image = picture((struct picture){.linewidth = 1.5, .chaos = 1});
    char palette[7] = {8};
    for (size_t colour= 1; colour < count(palette); ++colour) {
        const size_t shuffle = any(colour);
        palette[colour] = palette[shuffle];
        palette[shuffle] = colour;
    }
    size_t colour = 0;
    pdf = generate(pdf, "1 j 1 J %.2f w\n", image.linewidth mm);
    for (size_t number = 0; number < count(image.object); ++number) {
        const struct object object = image.object[number];
        if (object.vectors) {
            const matrix transformation = concatenate(object.transformation, composition);
            if (object.vectors / magic <= 2) {
                pdf = generate(pdf, "0 0 0 1 K %.2f w\n", image.linewidth mm);
                for (size_t number = 1; number < object.vectors; ++number) {
                    pdf = generate(point(pdf, transform(object.vector[number - 1], transformation)), "m\n");
                    pdf = generate(point(pdf, transform(object.vector[number], transformation)), "l\n");
                }
                pdf = generate(pdf, "s\n");
            } else {
                assert(colour < count(palette));
                const char ink = palette[colour++];
                enum cmyk {cyan = 1, magenta = 2, yellow = 4, black = 8};
                const char cmyk[] = {
                    '0' + (bool)(ink & cyan), ' ',
                    '0' + (bool)(ink & magenta), ' ',
                    '0' + (bool)(ink & yellow), ' ',
                    '0' + (bool)(ink & black), '\0'
                };
                pdf = generate(pdf, "%s k %s K %.2f w\n", cmyk, cmyk, image.linewidth mm);
                for (size_t number = 1; number < object.vectors; ++number) {
                    pdf = generate(point(pdf, transform(object.vector[number - 1], transformation)), "m\n");
                    pdf = generate(point(pdf, transform(object.vector[number], transformation)), "l\n");
                }
                pdf = generate(pdf, "s 0 w\n");
                pdf = generate(point(pdf, transform(object.vector[0], transformation)), "m\n");
                for (size_t number = 1; number < object.vectors; ++number)
                    pdf = generate(point(pdf, transform(object.vector[number], transformation)), "l\n");
                pdf = generate(pdf, "h f\n");
            }
        }
    }
    image = erase(image);
    return pdf;
}

static struct pdf print(struct pdf pdf, const unsigned number, const vector pagesize, const vector margin)
{
    const size_t resources = (pdf = dictionary(pdf, "/ProcSet [/PDF]")).object.number;
    const matrix composition = center(scalar(pagesize.y - margin.y), pagesize);
    for (unsigned print = 0; print < number; ++print) {
        const struct pdf stream = (pdf = startpage(pdf, pagesize, resources));
        pdf = paint(pdf, composition);
        pdf = endpage(pdf, stream);
    }
    return pdf;
}

static int error(const size_t pages)
{
    (void)fprintf(stderr, "    [1 .. %lu pages]\n", pages);
    return 0;
}

int inkjet(void * const device, const int number)
{
    struct pdf pdf = {0};
    if (number < 1 || (size_t)number > count(pdf.page.object)) {
        return error(count(pdf.page.object));
    } else {
        pdf = endpdf(print(startpdf(
            (struct pdf){.write = output, .device = device, .title = "unreliable objects", .author = "David W. Speck"}
        ), number, landscape(a5), scalar(0.0)));
        return 1;
    }
}

int card(void * const device, const int number)
{
    struct pdf pdf = {0};
    if (number < 1 || (size_t)number > count(pdf.page.object) - 1) {
        return error(count(pdf.page.object) - 1);
    } else {
        pdf = startpdf(
            (struct pdf){.write = output, .device = device, .title = "unreliable objects", .author = "David W. Speck"}
        );
        const vector pagesize = landscape(a6);
        const vector margin = scalar(7.5 mm);
        pdf = print(pdf, number, pagesize, margin);
        const size_t textresources = (pdf = dictionary(pdf,
            "/ProcSet [/PDF /text] /Font <<\n"
            "  /Courier-Bold <<\n"
            "    /Type /Font /Subtype /Type1 /Name /Courier-Bold /BaseFont /Courier-Bold /Encoding /MacRomanEncoding\n"
            "  >> /Courier-BoldOblique <<\n"
            "    /Type /Font /Subtype /Type1 /Name /Courier-BoldOblique /BaseFont /Courier-BoldOblique /Encoding /MacRomanEncoding\n"
            "  >>\n"
            ">>"
        )).object.number;
        const struct pdf stream = (pdf = startpage(pdf, pagesize, textresources));
        const double fontsize = 10;
        const double leading = fontsize * 1.2;
        pdf = generate(point(generate(pdf,
            "BT %0.2f TL ", leading), add((vector){.y = 5 * leading}, margin)), "Td\n"
            "/Courier-Bold %0.2f Tf (unreliable objects) '\n"
            "/Courier-BoldOblique %0.2f Tf (unzuverl\\212ssige objekte) '\n"
            "/Courier-Bold %0.2f Tf () '\n"
            "(David W. Speck, 2025) '\n"
            "(rndmao.org/dws) '\n"
            "ET\n", fontsize, fontsize, fontsize
        );
        pdf = endpdf(endpage(pdf, stream));
        return 1;
    }
}