#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
#include <string.h>
#include <limits.h>

#include "lfcrypto.h"
#include "lfvector.h"
#include "lfinput.h"
#include "lfparsing.h"
#include "helpers.h"

static void challenge1() {
    const char *input = "49276d206b696c6c696e6720796f757220627261696e206c696b65206120706f69736f6e6f7573206d757368726f6f6d";
    size_t sz = 0;
    const unsigned char *hex = hex_decode(input, &sz);
    unsigned char *s = b64_encode(hex, sz);
    printf("01-01: %s\n", s);

    free(hex);
    free(s);
}

static void challenge2() {
    const char *input = "1c0111001f010100061a024b53535009181c";
    size_t sz = 0;
    const unsigned char *hex = hex_decode(input, &sz);

    const char *input2 = "686974207468652062756c6c277320657965";
    size_t sz2 = 0;
    const unsigned char *hex2 = hex_decode(input2, &sz2);

    unsigned char *sol = malloc(sizeof(unsigned char) * sz);
    for (size_t i = 0; i < sz; ++i) {
        sol[i] = hex[i] ^ hex2[i];
    }

    printf("01-02: ");
    for (size_t i = 0; i < sz; ++i) {
        printf("%x", sol[i]);
    }
    printf("\n");

    free(hex);
    free(hex2);
    free(sol);
}

static void challenge3() {
    const char *input = "1b37373331363f78151b7f2b783431333d78397828372d363c78373e783a393b3736";
    size_t sz = 0;
    unsigned char *hex = hex_decode(input, &sz);
    char answer[256];

    int score = 0;
    for (char c = 0; c < CHAR_MAX; ++c) {
        const char *encode = one_byte_xor_s(hex, sz, c);
        int t = simple_english_scoring(encode);
        if (t > score && strstr(encode, "\n") == NULL) {
            score = t;
            strncpy(answer, encode, 256);
        }
        free(encode);
    }
    printf("01-03: %s\n", answer);
    free(hex);
}

static void challenge4() {
    size_t lines_sz = 0;
    char **lines = get_lines("input/1-4", &lines_sz);
    char answer[256];
    int score = 0;

    for (size_t i = 0; i < lines_sz; ++i) {
        size_t hex_sz = 0;
        unsigned char *hex = hex_decode(lines[i], &hex_sz);
        for (char c = 0; c < CHAR_MAX; ++c) {
            const char *encode = one_byte_xor_s(hex, hex_sz, c);
            int t = simple_english_scoring(encode);
            if (t > score) {
                score = t;
                strncpy(answer, encode, 256);
            }
            free(encode);
        }
        free(hex);
    }

    printf("01-04: %s", answer);
    del_lines(lines);
}

static void challenge5() {
    char *input = "Burning 'em, if you ain't quick and nimble\nI go crazy when I hear a cymbal";
    const unsigned char* x = repeating_key_xor_s(input, "ICE");
    const char *answer = hex_encode(x, strlen(input));
    printf("01-05: %s\n", answer);
    free(x);
    free(answer);
}

static void challenge6_vecdestroy(void *v) {
    if (v == NULL) {
        return;
    }
    vec_destroy((Vector *)v);
    free(v);
}

static void challenge6() {
    char *input = get_input("input/1-6"); 
    size_t encoded_sz = 0;
    unsigned char *encoded = b64_decode(input, strlen(input), &encoded_sz);


    unsigned int smallest = UINT_MAX;
    size_t keysize = 0;
    for (size_t k = 2; k <= 20; ++k) {
        char a[41], b[41];
        strncpy(a, encoded, k);
        strncpy(b, encoded + k, k);
        unsigned int hd = hamming_distance_s(a, b) / (unsigned int)keysize;
        if (hd < smallest) {
            smallest = hd;
            keysize = k;
        }
    }
    /*
    for (unsigned char *c = encoded; *c != '\0'; ++c) {
        printf("%02x", *c);
    }
    printf("\n");
    */
    /*

    Vector *vec = malloc(sizeof(Vector));
    vec_init(vec, challenge6_vecdestroy);

    // Account for remainders
    size_t vec_sz = encoded_sz / keysize;
    if (encoded_sz % keysize != 0) {
        ++vec_sz;
    }
    for (size_t i = 0; i < vec_sz; ++i) {
        Vector *vec_t = malloc(sizeof(Vector));
        vec_init(vec_t, free);
        vec_push(vec, (void *)vec_t);
    }

    for (size_t i = 0; i < encoded_sz; ++i) {
        unsigned char *c = malloc(sizeof(unsigned char));
        *c = encoded[i];
        vec_at(vec, i % keysize) = c;
    }

    vec_destroy(vec);
    */
    free(encoded);
    free(input);
}

void set1() {
    challenge1();
    challenge2();
    challenge3();
    challenge4();
    challenge5();
    challenge6();
}