//
// Created by rick on 06-02-21.
//

#include <attributes.h>
#include <stdio.h>
#include <string.h>

#include <myke/vfs/blockdev.h>
#include <myke/libk/libk.h>
#include <myke/tasks/locking.h>
#include <myke/tasks/task.h>
#include <myke/util/init.h>

#define MAX_BLOCK_DEVS 64

int last_block_dev = 0;
block_device_t block_devices[MAX_BLOCK_DEVS] = {0};

extern struct block_dev_driver __start_block_dev_driver[];
extern struct block_dev_driver __stop_block_dev_driver[];
#define NUM_DRIVERS ((size_t)(__stop_block_dev_driver - __start_block_dev_driver))
#define DRIVER(i) ((__start_block_dev_driver) + (i))

semaphore_t *block_semaphore;
bool blockdev_task_running = false;

block_device_t *block_dev_get_by_id(const char *name) {
    for (int i = 0; i < last_block_dev; ++i) {
        if (block_devices[i].flags.present
            && strcmp(block_devices[i].identifier, name) == 0) {
            return &block_devices[i];
        }
    }
    return NULL;
}

block_dev_driver_t *block_dev_driver_by_name(const char *name) {
    for (size_t i = 0; i < NUM_DRIVERS; ++i) {
        if (strcmp(DRIVER(i)->name, name) == 0) {
            return DRIVER(i);
        }
    }
    return NULL;
}

uint8_t block_dev_register(block_device_t *device) {
    if (last_block_dev >= MAX_BLOCK_DEVS - 1) {
        return BLOCK_DEV_REGISTER_FULL;
    }

    memcpy((uint8_t *) &block_devices[last_block_dev++], (const uint8_t *) device, sizeof(block_device_t));

    if (blockdev_task_running) {
        semaphore_signal(block_semaphore);
    }
    return BLOCK_DEV_REGISTER_OK;
}

void *block_dev_mount(const char *device, const char *driver_name) {
    if (device == NULL || driver_name == NULL || strlen(device) == 0 || strlen(driver_name) == 0) {
        return NULL; // invalid input
    }
    block_device_t *dev = block_dev_get_by_id(device);
    if (dev == NULL) {
        return NULL;
    }
    block_dev_driver_t *driver = block_dev_driver_by_name(driver_name);
    if (driver == NULL) {
        return NULL;
    }
    if (driver->check_device(dev) == BLOCK_DEV_DRIVER_CHECK_OK) {
        dev->driver = driver;
        return dev->driver_info;
    }
    return NULL;
}

void block_dev_free(block_device_t *device) {
    //todo
    k_panics("block dev free not supported");
}

int block_dev_num_not_scanned() {
    int not_scanned = 0;
    for (int i = 0; i < last_block_dev; ++i) {
        if (block_devices[i].flags.present && !block_devices[i].flags.scanned) not_scanned++;
    }
    return not_scanned;
}

void block_dev_scan() {
    int c_last_block_dev = last_block_dev;
    for (int i = 0; i < c_last_block_dev; ++i) {
        if (block_devices[i].flags.scanned || !block_devices[i].flags.present) continue;
        for (size_t j = 0; j < NUM_DRIVERS; ++j) {
            // only partitioning drivers are automatically assigned
            if (!DRIVER(i)->flags.partitioning) {
                continue;
            }
            // only root devices have partitions
            if (!block_devices[i].flags.root_device) {
                continue;
            }

            // let the driver test the disk
            uint8_t driver_result = DRIVER(j)->check_device(&block_devices[i]);
            if (driver_result == BLOCK_DEV_DRIVER_CHECK_OK) {
                block_devices[i].driver = DRIVER(j);
                block_devices[i].flags.driver_installed = 1;
                break;
            }
        }
        block_devices[i].flags.scanned = 1;
    }
}

void att_noreturn block_dev_task(void *data) {
    while (true) {
        semaphore_wait(block_semaphore);
        block_dev_scan();
    }
}

void block_dev_start_task() {
    block_semaphore = semaphore_create(1);
    blockdev_task_running = true;
    task_spawn(block_dev_task, NULL, "blockdev");
}

void block_dev_print_info() {
    printf("Block devices:\n");
    for (int i = 0; i < last_block_dev; ++i) {
        printf("-%s driver: %s\n",
               block_devices[i].identifier,
               block_devices[i].flags.driver_installed ? block_devices[i].driver->name : "n/a");
    }
}

INIT_FUNCTION(100) = {
        .name = "blockdev-task",
        .stage = INIT_STAGE_PRE_TASKING,
        .init = block_dev_start_task,
};