import archive.tar
import flag
import net.http
import os
import term

const default_url = 'https://github.com/vlang/v/archive/refs/tags/v0.1.3.tar.gz'

@[heap]
struct Context {
    url        string // Web starting with http:// or https://. Local starting with file:///
    chunks     bool   // true: decompress with callback
    debug      int    // print debug lines
    max_blocks int    // if max_blocks > 0 and is reached stops early.
    filename   string // if filename is found as a path of a data block, stops early.
}

fn (ctx &Context) read_last_block(mut read tar.Read) bool {
    if ctx.max_blocks > 0 && ctx.max_blocks < read.get_block_number() {
        read.stop_early = true
        return true
    }
    return false
}

fn new_context() !&Context {
    mut fp := flag.new_flag_parser(os.args)
    fp.application('tar_gz_reader')
    fp.version('0.0.20250721')
    fp.description('Reads into memory selected sections of *.tar.gz. archives from https or home_dir.')
    fp.skip_executable()
    ctx := &Context{
        url:        fp.string('url', `u`, default_url,
            'archive *.tar.gz URL, default(${default_url}). Start name with file:/// for local')
        chunks:     fp.bool('chunks', `c`, false,
            'decompress with chunks to reduce RAM usage, default(false)')
        debug:      fp.int('debug', `d`, 0,
            'prints blocks: 1=other, 2:+dirs, 3=+files, 4=+data, default(0=silent)')
        max_blocks: fp.int('max_blocks', `m`, 0,
            'maximum blocks to read, stop early. Default(0=read all)')
        filename:   fp.string('filename', `f`, '',
            'filename content complete print, stop early. Default(empty means none)')
    }
    additional := fp.finalize()!
    if additional.len > 0 {
        println('unprocessed args ${additional.join_lines()}')
    }
    return ctx
}

// Downloader downloads a *.tar.gz using HTTP chunks
struct Downloader {
mut:
    chunks int
    data   []u8
}

fn new_downloader(url string) !&Downloader {
    mut downloader := &Downloader{}
    params := http.DownloaderParams{
        downloader: downloader
    }
    if url.starts_with('http://') || url.starts_with('https://') {
        http.download_file_with_progress(url, '', params)!
    } else if url.starts_with('file:///') {
        path := '${os.home_dir()}/${url[8..]}'
        println('path ${path}')
        downloader.data = os.read_bytes(path)!
    }
    return downloader
}

fn (mut d Downloader) on_start(mut _request http.Request, _path string) ! {}

fn (mut d Downloader) on_chunk(_request &http.Request, chunk []u8, _already_received u64, expected u64) ! {
    if expected == 0 {
        return
    }
    d.chunks++
    d.data << chunk
}

fn (mut d Downloader) on_finish(_request &http.Request, _response &http.Response) ! {}

struct FileReader implements tar.Reader {
    ctx &Context
mut:
    filepath string
    content  []u8
}

fn (mut f FileReader) other_block(mut read tar.Read, details string) {
    if f.ctx.read_last_block(mut read) {
        return
    }
    if f.ctx.debug > 0 {
        row := 'OTHER  block:${read.get_block_number():6} ${read.get_special()} ${details} ${read.get_path()} '
        println(term.colorize(term.bright_yellow, row))
    }
}

fn (mut f FileReader) dir_block(mut read tar.Read, size u64) {
    if f.ctx.read_last_block(mut read) {
        return
    }
    if f.ctx.debug > 1 {
        row := 'DIR    block:${read.get_block_number():6} ${read.get_path()} size:${size}'
        println(term.colorize(term.green, row))
    }
}

fn (mut f FileReader) file_block(mut read tar.Read, size u64) {
    if f.ctx.read_last_block(mut read) {
        return
    }
    path := read.get_path()
    if f.ctx.debug > 2 {
        row := ' FILE  block:${read.get_block_number():6} ${path} size:${size}'
        println(term.colorize(term.bright_blue, row))
    }
    if f.ctx.filename != '' && f.filepath == '' && path.ends_with(f.ctx.filename) {
        f.filepath = path
    }
}

fn (mut f FileReader) data_block(mut read tar.Read, data []u8, pending int) {
    if f.ctx.read_last_block(mut read) {
        return
    }
    path := read.get_path()
    if f.ctx.debug > 3 {
        println('  DATA block:${read.get_block_number():6} ${path} len:${data.len} pend:${pending}')
    }
    if f.ctx.filename != '' {
        if f.filepath == path {
            f.content << data
            if pending == 0 {
                // our file of interest data is complete
                read.stop_early = true
            }
        }
    }
}

fn main() {
    ctx := new_context()!
    reader := FileReader{
        ctx: ctx
    }
    mut untar := tar.new_untar(reader)
    mut decompressor := tar.new_decompressor(untar)
    downloader := new_downloader(ctx.url)!
    if ctx.chunks {
        decompressor.read_chunks(downloader.data)!
    } else {
        decompressor.read_all(downloader.data)!
    }
    println('-'.repeat(80))
    println('Download: ${ctx.url} chunks:${downloader.chunks} bytes=${downloader.data.len}')
    println('Untar:    ${untar}')
    println('Content:  Path:${reader.filepath} bytes:${reader.content.len}')
    println('-'.repeat(80))
    println('${reader.content.bytestr()}')
    println('-'.repeat(80))
}