# То же самое, но на julia

using Logging
using Printf
using Dates
using CRC32c
using JSON
using Base.Threads
using MySQL
# using DBInterface
   
# debuglogger = ConsoleLogger(stderr, Logging.Debug)
# global_logger(debuglogger)

# правильный перевод!
function humanbytes(B)
    """Return the given bytes as a human friendly KB, MB, GB, or TB string."""
    B = float(B)
    KB = float(1024)
    MB = float(KB ^ 2) # 1,048,576
    GB = float(KB ^ 3) # 1,073,741,824
    TB = float(KB ^ 4) # 1,099,511,627,776

    if B < KB
        return @sprintf("%.2f Bytes", B)
    elseif KB <= B && B < MB
        return @sprintf("%.2f KB", (B / KB))
    elseif MB <= B && B < GB
        return @sprintf("%.2f MB", (B / MB))
    elseif GB <= B && B < TB
        return @sprintf("%.2f GB", (B / GB))
    elseif TB <= B
        return @sprintf("%.2f TB", (B / KB))
    end
end

function new_name(name)
    matches = Dict(
        "Сек" => r"(.+) Сек.*",
        "Сцен" => r"(.+) Сцен.*",
        "Голые" => r"(.+) Голые.*",
        "Откро" => r"(.+) Откро.*",
        "Посте" => r"(.+) Посте.*",
        "Изнас" => r"(.+) Изнас.*",
        "Инцес" => r"(.+) Инцес.*",
        "Лесб" => r"(.+) Лесб.*",
        "Эро" => r"(.+) Эро.*"
    )
    for (k, v) in matches
        if contains(name, k)
            base, ext = splitext(name)
            new_name = replace(base, v => s"\1")
            # @debug base, new_name
            return string(new_name, ext)
        end
    end
    return name
end

function valid_file(filename)
    valids = [".mp4", ".webm", ".mpeg"]
    _, ext = splitext(filename)
    return ext in valids
end

# file_info function returns information from file
function file_info(filename)
    _, ext = splitext(filename)
    info = stat(filename)
    crc = CRC32c.crc32c(open(filename, "r"))
    m = Dict(
        "filename" => filename,
        "size" => info.size,
        "hsize" => humanbytes(info.size),
        "mtime" => info.mtime,
        "ctime" => info.ctime,
        "htime" => Dates.format(Dates.unix2datetime(info.ctime), "dd.mm.yyyy"),
        "ext" => ext,
        "crc"=> Int(crc),
    )
    return m
end

function file_meta(filename)
    cmd = `ffprobe -v quiet -print_format json -show_format -show_streams "$filename"`
    out = read(cmd, String)
    data = JSON.parse(out)
    # println(data["format"]["duration"])
    res = Dict(
        "duration" => data["format"]["duration"],
    )
    return res
end

function check_file(filename)
    # println(filename)
    v1 = file_info(filename)
    v2 = file_meta(filename)  
    result = merge!(v1, v2)
    # println(info)  
    return result
end

function parallel_execution()
    nthreads = Threads.nthreads()  # Получаем количество доступных потоков
    println("Running parallel execution: $(nthreads)")
    results = Vector{Int}(undef, nthreads)  # Создаем массив для хранения результатов

    # Создаем и запускаем потоки
    v = 0
    @sync begin       
        for i in 1:24
            Threads.@spawn begin
                # Код, который нужно выполнить параллельно
                # return i * 2
                v += 1
                println("Hello from ", Threads.threadid())
            end
        end
    end

    println("loop finished: ", v)

    # Получаем результаты из потоков
    # for i in 1:nthreads
    #     # v = results[i]
    #     println("Результат из потока $i: $v")
    # end
end

function main()
    dir = "d:\\vids\\ero"
    @info  "Обработка каталога: $dir"
    
    files = readdir(dir, join=true)
    n = length(files)
    println("всего: $n files")

    @time begin
        @sync begin
            for file in filter(valid_file, files)
                Threads.@spawn begin
                    meta = check_file(file)
                    println(meta)
                end
            end
        end
    end

    println("обработано")
end

function openDB()
    conn = DBInterface.connect(MySQL.Connection, "xigmanas", "itman", "X753951x", db="sea")
    # conn.db = "sea"
    # println("DB: ", conn)
    limit = 2
    ext = ".webp"
    cmd = "select ext, newurl from filemeta where ext = '$ext' limit $limit"
    result = DBInterface.execute(conn, cmd)
    # println(typeof(result))
    for s in result
        println(s.ext,' ',  s.newurl)
    end
end
# -------- основная программа --------------
# parallel_execution()
# openDB()
main()