// about
    // licenze:
        // This code and its derivatives can be used under the following conditions:
        // - Do not attack other countries.
        // - Jerk off on public at least 1 time per day.
        // - Observe hygiene.
        // - check my other projects https://chiselapp.com/user/sergey6661313
    
    // about:
        // ScalpiEditor - ansi-only text editor for terminals.
        // killer features: no. its just editor.
    
    // Compile:
        // WORK IN PROGRESS (not writed yet!)
        // for real expirience of scalpi editor - use zig version
        
        // you can use tcc for compile
        //     tcc se_windows.c
    
    // to support me
        // with boosty:
            // https://boosty.to/cutloosedev
        
        // with monero:
            // 87T7 qGbA TrM3 a6Br
            // DyeC jQQf NWtU u3iZ
            // bHVB MC6W mEbN NE13
            // Qrrt KhBb e4vF 58NR
            // 8PTF dYk2 Sozc HexX
            // 4Q69 jbdQ Asrs P7B

// imports
    
    // libC
    #include "assert.h"
    #include "ctype.h"
    #include "errno.h"
    #include "fenv.h"
    #include "float.h"
    #include "inttypes.h"
    #include "iso646.h"
    #include "limits.h"
    #include "locale.h"
    #include "math.h"
    #include "setjmp.h"
    #include "signal.h"
    #include "stdarg.h"
    #include "stdbool.h"
    #include "stddef.h"
    #include "stdint.h"
    #include "stdio.h"
    #include "stdlib.h"
    #include "string.h"
    #include "tgmath.h"
    #include "time.h"
    #include "uchar.h"
    #include "wchar.h"
    #include "wctype.h"
    
    // Windows
    #include "windows.h"
    #include "windef.h"
    #include "winuser.h"
    #include "commctrl.h"
    #include "io.h"
    #include "conio.h"
    
    // network
    //#include "ws2tcpip.h"
    //#include "winsock.h"

// macroses
    #define length(array) ((sizeof(array)) / (sizeof(array[0])))
    
    void printHex(uint8_t buffer[], uintptr_t buffer_len) {
        for (int i = 0; i < buffer_len; i++) {
            printf("%02X", buffer[i]);
        }
    }

// settings

// types
    struct Os_Console_Output {
        void* handle;
        void* file;
        void* writer;
    };
    
    struct WriterVTable {
        uint64_t (*write) (void* context, uint8_t* bytes, uint64_t bytes_len, uint64_t* writed_result);
    };
    
    struct Scalpi_Writer {
        void* context;
        struct WriterVTable* vtable;
    };
    
    struct Scalpi_Logger {
        // write to terminal, console, file or to all together, but no real check "bytes is writen"
        
        uint64_t writed;
        struct Scalpi_Writer writer;
        
        bool file_work;
        uintptr_t file;
        
        bool file_writer_work;
        struct Scalpi_Writer* file_writer;
        
        bool console_writer_work;
        struct Scalpi_Writer* console_writer;
        
        bool  terminal_writer_work;
        struct Scalpi_Writer* terminal_writer;
    };
    struct Scalpi_Console {
        void* input;
        void* output;
    };
    struct App {
        struct Scalpi_Logger logger;
    };
    
// function prototypes
    uint64_t Scalpi_logger_write(struct Scalpi_Logger* t, uint8_t* bytes, uint64_t bytes_len, uint64_t* writed_result);

// globals
    struct App global_app;
    
    struct WriterVTable Scalpi_logger_writer_vtable = {
        .write = 
            (uint64_t (*) (void*, uint8_t*, uint64_t, uint64_t*)) 
            &Scalpi_logger_write
    };

// functions
    void os_print(uint8_t* bytes, uint64_t bytes_len) {
        uint8_t* byte_ptr = bytes;
        while (bytes_len > 0) {
            putchar(*byte_ptr);
            bytes_len -= 1;
            byte_ptr += 1;
        }
    }
    
    // void Os_Console_Output_init(&global_app.console.output, c.GetStdHandle(c.STD_OUTPUT_HANDLE));
    uint64_t writeToWriter(struct Scalpi_Writer* w, uint8_t bytes[], int bytes_len) {
        return 1;
    };
    
    // Scalpi_logger
        uint64_t Scalpi_logger_write(struct Scalpi_Logger* t, uint8_t* bytes, uint64_t bytes_len, uint64_t* writed_result) {
            uint64_t r = 0;
            *writed_result = 0;
            bool writed = false;
            
            if (t->file_writer_work) {
                r = writeToWriter(t->file_writer, bytes, bytes_len);
                writed = true;
            }
            
            if (t->console_writer_work) {
                r = writeToWriter(t->console_writer, bytes, bytes_len);
                writed = true;
            }
            
            if (t->terminal_writer_work) {
                r = writeToWriter(t->terminal_writer, bytes, bytes_len);
                writed = true;
            }
            
            if (writed == false) {
                os_print(bytes, bytes_len);
            }
            
            t->writed += bytes_len;
            *writed_result = bytes_len;
            return 0;
        }
        
        uint64_t Scalpi_logger_writeAll(struct Scalpi_Logger* t, uint8_t* bytes, uint64_t bytes_len){
            uint64_t writed = 0;
            return Scalpi_logger_write(t, bytes, bytes_len, &writed);
        }
        
        void Scalpi_logger_init (struct Scalpi_Logger* t) {
            t->writed = 0;
            
            // init writer
            t->writer.vtable = &Scalpi_logger_writer_vtable;
            t->writer.context = t;
            
            t->file_work = false;
            t->file_writer_work = false;
            t->console_writer_work = false;
            t->terminal_writer_work = false;
        }
    
    // App
        bool App_init(struct App* app) {
            // preinit console output for debug
            Scalpi_logger_init(&app->logger);
            return true;
        }
        
        void App_deinit(struct App* global_app) {}
        
        void App_loop(struct App* global_app) {}
    
    // main
        bool real_main() {
            printf(" se_windows.c \r\n");
            if (App_init(&global_app)) {
                App_loop(&global_app);
                App_deinit(&global_app);
                return true;
            } else {
                printf("%d: fail App_init\r\n", __LINE__);
            }
            
            return false;
        }
        
        int main() {
            if (real_main()) return 0;
            return 1;
        }