// core
        #define Endians_Little 1
        #define Endians_Big 2
    
    // time
        #define Scalpi_time_ms_per_s 1000
    
    // Scalpi_Logger_writers
        #define Scalpi_Logger_writers_c_out_writer 0
        #define Scalpi_Logger_writers_file_writer 1
        #define Scalpi_Logger_writers_console_writer 2
        #define Scalpi_Logger_writers_terminal_writer 3
    
    // Scalpi_Console_ansi
        #define Scalpi_Console_ansi_esc                          "\x1B"

// macroses
    // c
        #define or ||
        #define and &&
        #define OFFSETOF(type, field) ((size_t) &(((type *)0)->field))
        #define FIELD_PARENT_PTR(type, field, instance) ((type *)((char *)(instance) - OFFSETOF(type, field)))
        #define LEN(array) (sizeof(array) / sizeof(array[0]))
        #define TEXT_LEN(str) (LEN(str) - 1)
    
    // text
        #define SLICE_TEXT(text) {.ptr=text, .len=TEXT_LEN(text)}
        #define TEXT_PTR(text) (char(*)[TEXT_LEN(text)]) text
        #define DEF_TEXT_PTR(name, text) char(*name)[TEXT_LEN(text)] = TEXT_PTR(text)
        #define DEF_SLICE_TEXT(name, text) struct Slice name = SLICE_TEXT(text)

// types
    // core
        // memory
            typedef size_t (*WriteFnPtr) (void* context, const char* bytes, size_t bytes_len);
            
            struct Slice {
                char* ptr;
                size_t len;
            };
            
            struct Finder {
                struct Slice text;

                DWORD output_mode;
            #elif defined(__linux__)
                struct termios termios;
            #endif
        };
        
        // Os_Console_Input_Handle
            #ifdef _WIN32
                typedef void* Os_Console_Input_Handle;
            #elif defined(__linux__)
                typedef FILE* Os_Console_Input_Handle;
            #endif
        
        struct Os_Console_Input {
            Os_Console_Input_Handle handle;
            #ifdef _WIN32
            #elif defined(__linux__)
                int fileno;
            #endif
        };
        
        // Os_Console_Output_Handle
            #ifdef _WIN32
                typedef void* Os_Console_Output_Handle;
            #elif defined(__linux__)
                typedef FILE* Os_Console_Output_Handle;
            #endif
        
        struct Os_Console_Output {
            Os_Console_Output_Handle handle;
            #ifdef _WIN32
            #elif defined(__linux__)
                int fileno;
            #endif
        };
        
    // Scalpi
        // text
            struct Scalpi_Text_Splitter {
                struct Finder finder;
                bool stop;
                size_t last_pos;
            };
        
        // Scalpi
            struct Scalpi_Writer {
                void* context;
                WriteFnPtr write;
            };
            
            struct Scalpi_Logger {
                // write to terminal, console, file or to all together, but no real check "bytes is writen"
                struct Scalpi_Writer writers[4] // Scalpi_Logger_writers
            };
            
            struct Scalpi_Console {
                struct Os_Console_Input input;
                struct Os_Console_Output output;
            };
    
    // App
        struct App_Os_Helper {
            #ifdef _WIN32
                // WinApi 
                HINSTANCE instance;

    
// function prototypes

// globals
    struct App global_app;

// functions

    // core
        // mem
            // bits operations
                uint8_t bits_rotl8(uint8_t value, unsigned int shift) {
                    shift %= 8;
                    return (value << shift) | (value >> (8 - shift));
                }

                
                uint64_t bits_rotl64(uint64_t value, unsigned int shift) {
                    shift %= 64;
                    return (value << shift) | (value >> (64 - shift));
                }
            
            // bytes operations
                size_t Scalpi_mem_fill(char* dest, char symbol, size_t len) {
                    for (size_t pos = 0; pos < len; pos++) {
                        dest[pos] = symbol;
                    }
                }
                
                size_t Scalpi_mem_write(char* dest, char* src, size_t size) {
                    // i use this instead memcpy becouse clang-in-zig just replace memcpy to crash-zig-bloated-version code
                    size_t pos;
                    for(pos = 0; pos < size; pos++) {
                        dest[pos] = src[pos];
                    }
                    return pos;
                }
                
                bool Scalpi_mem_isEql(char* a, char* b, size_t len) {
                    for(size_t pos = 0; pos < len; pos ++) {
                        char ac = a[pos];
                        char bc = b[pos];
                        if (ac != bc) return false;
                    }
                    
                    return true;
                }
                
                void writeWithOffset(char* dest, size_t* writed, char* data, size_t data_len) {
                    Scalpi_mem_write(&dest[*writed], data, data_len);
                    *writed += data_len;
                }
            
            // format_number
                // copy non aligned data
                    void memcpy2(char* dest, char* src) {
                        dest[0] = src[0];

        
        void Os_sleep(uint64_t ms) {
            #ifdef _WIN32
                Sleep(ms);
            #endif
            // TODO ME FOR LINUX
        }
        
        void Os_Console_Output_init(struct Os_Console_Output* output, Os_Console_Output_Handle handle) {
            output->handle = handle;
            #ifdef _WIN32
                // output->handle = GetStdHandle(c.STD_OUTPUT_HANDLE);
            #elif defined(__linux__)
                // output->handle = stdout
                output->fileno = fileno(output->handle);
            #endif
        }
        
        void Os_Console_Input_init(struct Os_Console_Input* input, Os_Console_Input_Handle handle) {
            input->handle = handle;
            #ifdef _WIN32
                // output->handle = GetStdHandle(c.STD_INPUT_HANDLE);
            #elif defined(__linux__)
                // output->handle = stdout
                input->fileno = fileno(input->handle);
            #endif
        }
        
        size_t Os_Console_Output_write(struct Os_Console_Output* output, const char* text, size_t len) {
            #ifdef _WIN32
                size_t writed = 0;
                WriteConsoleA(output->handle, text, len, &writed, 0);
            #elif defined(__linux__)
                //write(output->fileno, text, len);
                fwrite(text, sizeof(char), len, output->handle);
            #endif
            
            return len;
        }
    
    // Scalpi lib
        // C_Text
            size_t C_Text_getLen(const char text[]) {
                size_t len = 0;
                while(text[len] != 0) len++;
                return len;
            }
            
            size_t C_Text_write(char buffer[], char data[]) {
                const size_t len = C_Text_getLen(data);
                return Scalpi_mem_write(buffer, data, len);
            }
            
            size_t C_Text_writeToWriteFn(WriteFnPtr write, void* context, const char text[]) {
                const size_t len = C_Text_getLen(text);
                return write(context, text, len);
            }
        
        // Scalpi_Text_writeU64AsText
            #define Scalpi_Text_CharsDecFromU64_MAX_LEN  TEXT_LEN("18446744073709551615")
            
            size_t Scalpi_Text_writeU64AsText(char buffer[], uint64_t number, size_t min_width) { // utoa
                size_t writed = 0;
                
                // write number to tmp
                char buffer_tmp[Scalpi_Text_CharsDecFromU64_MAX_LEN];
                uintptr_t tmp_ptr = (uintptr_t) &buffer_tmp[0] + Scalpi_Text_CharsDecFromU64_MAX_LEN;
                for (uint64_t num = number; num > 0; num = num / 10) {
                    uint8_t remainder = num % 10;
                    tmp_ptr--;
                    *(char*)tmp_ptr = '0' + (char) remainder;
                }
                const uintptr_t writed_tmp = (uintptr_t) &buffer_tmp[0] + Scalpi_Text_CharsDecFromU64_MAX_LEN - (uintptr_t) tmp_ptr;
                
                // fill zeroes to min_width
                size_t extra_fill = 0;
                if (min_width > writed_tmp) {
                    extra_fill = min_width - writed_tmp;
                    writed += Scalpi_mem_fill(&buffer[0], '0', extra_fill);
                }
                
                if (writed_tmp > 0) writed += Scalpi_mem_write(&buffer[writed], (char*)tmp_ptr, writed_tmp);
                return writed;
            }
            
            size_t Scalpi_Text_writeU64AsTextToWriteFn(WriteFnPtr write, void* context, uint64_t number, size_t min_width) {
                char buffer_tmp[Scalpi_Text_CharsDecFromU64_MAX_LEN];
                const size_t writed = Scalpi_Text_writeU64AsText(buffer_tmp, number, min_width);
                return write(context, buffer_tmp, writed);
            }
        
        // Scalpi_Logger
            void Scalpi_Logger_init (struct Scalpi_Logger* t) {
                for (int i = 0; i < LEN(t->writers); i++) {
                    struct Scalpi_Writer* w = &t->writers[i];
                    w->context = 0;
                    w->write = 0;
                }
            }
            
            size_t Scalpi_Logger_write(struct Scalpi_Logger* t, const char bytes[], size_t len) {
                for (size_t i = 0; i < LEN(t->writers); i++) {
                    struct Scalpi_Writer* w = &t->writers[i];
                    if (w->write) {
                        size_t writed = w->write(w->context, bytes, len);

                    }
                }
            }
    
    // App
        // struct App_Os_Helper
            bool App_Os_Helper_init(struct App_Os_Helper* os_helper) {

                    DispatchMessageA(&msg);
                #endif
                // TODO ME FOR LINUX
            }
        
        // struct App
            bool App_init(struct App* t) {
                Scalpi_Logger_init(&t->logger); // preinit console output for debug
                
                if (App_Os_Helper_init(&t->os_helper)) {
                    t->tick = os_getTick();
                    return true;
                    
                    // fallback
                    // App_Os_Helper_deinit(&t->os_helper);