/**********************************************************************
*
* File scanner
*
* Copyright (c) 2021 Dario Deledda. All rights reserved.
* Use of this source code is governed by an MIT license
* that can be found in the LICENSE file.
*
* TODO:
**********************************************************************/
import os

// STBI supported format
//        STBI_NO_JPEG *
//        STBI_NO_PNG  *
//        STBI_NO_BMP  *
//        STBI_NO_PSD
//        STBI_NO_TGA  *
//        STBI_NO_GIF  *
//        STBI_NO_HDR  *
//        STBI_NO_PIC  *
//        STBI_NO_PNM  *

/******************************************************************************
*
* Struct and Enums
*
******************************************************************************/
enum Item_type {
    file = 0
    folder
    // archive format
    zip = 16
    archive_file
    // graphic format, MUST stay after the other types!!
    bmp = 32
    jpg
    png
    gif
    tga
    ppm
    pgm
    pic
    hdr
}

pub struct Item {
pub mut:
    path                 string
    name                 string
    size                 u64
    i_type               Item_type = .file
    container_index      int  // used if the item is in a container (.zip, .rar, etc)
    container_item_index int  // index in the container if the item is contained
    need_extract         bool // if true need to extraction from the container
    drawable             bool // if true the image can be showed
    n_item               int  //
    rotation             int  // number of rotation of PI/2
}

struct Item_list {
pub mut:
    lst        []Item
    path_sep   string
    item_index int = -1 // image currently shown
    n_item     int  // number of images scanned
    loaded     bool // flag that indicate that the list is ready to  be used
}

/******************************************************************************
*
* Utility functions
*
******************************************************************************/
@[inline]
fn modulo(x int, n int) int {
    return (x % n + n) % n
}

@[inline]
fn get_extension(x string) Item_type {
    // 4 char extension check
    if x.len > 4 {
        ext4 := x[x.len - 4..].to_lower()
        match ext4 {
            // containers
            '.zip' { return .zip }
            // graphic formats
            '.jpg' { return .jpg }
            '.png' { return .png }
            '.bmp' { return .bmp }
            '.gif' { return .gif }
            '.tga' { return .tga }
            '.ppm' { return .ppm }
            '.pgm' { return .pgm }
            '.pic' { return .pic }
            '.hdr' { return .hdr }
            else {}
        }
    }
    // 5 char extension check
    if x.len > 5 {
        ext5 := x[x.len - 5..].to_lower()
        if ext5 == '.jpeg' {
            {
                return .jpg
            }
        }
    }
    return .file
}

@[inline]
fn is_image(x Item_type) bool {
    if int(x) >= int(Item_type.bmp) {
        return true
    }
    return false
}

@[inline]
fn is_container(x Item_type) bool {
    if x in [.zip, .folder] {
        return true
    }
    return false
}

@[inline]
fn (item_list Item_list) is_inside_a_container() bool {
    if item_list.lst.len <= 0 || item_list.n_item <= 0 {
        return false
    }
    return item_list.lst[item_list.item_index].need_extract
}

@[inline]
fn (item_list Item_list) get_file_path() string {
    if item_list.lst.len <= 0 || item_list.n_item <= 0 {
        return ''
    }
    if item_list.lst[item_list.item_index].path != '' {
        return '${item_list.lst[item_list.item_index].path}${item_list.path_sep}${item_list.lst[item_list.item_index].name}'
    }
    return item_list.lst[item_list.item_index].name
}

/******************************************************************************
*
* Scan functions
*
******************************************************************************/
fn (mut item_list Item_list) scan_folder(path string, in_index int) ! {
    println('Scanning [${path}]')
    mut folder_list := []string{}
    lst := os.ls(path)!

    // manage the single files
    for c, x in lst {
        pt := '${path}${item_list.path_sep}${x}'
        mut item := Item{
            path:                 path
            name:                 x
            container_index:      in_index
            container_item_index: c
        }
        if os.is_dir(pt) {
            folder_list << x
        } else {
            ext := get_extension(x)
            if ext == .zip {
                item.i_type = .zip
                item_list.lst << item
                item_list.scan_zip(pt, item_list.lst.len - 1)!
                continue
            }
            if is_image(ext) == true {
                item_list.n_item += 1
                item.n_item = item_list.n_item
                item.i_type = ext
                item.drawable = true
                item_list.lst << item
                continue
            }
        }
    }

    // manage the folders
    for x in folder_list {
        pt := '${path}${item_list.path_sep}${x}'
        item := Item{
            path:   path
            name:   x
            i_type: .folder
        }
        item_list.lst << item
        item_list.scan_folder(pt, item_list.lst.len - 1)!
    }
    // println(item_list.lst.len)
    // println("==================================")
}

fn (item_list Item_list) print_list() {
    println('================================')
    for x in item_list.lst {
        if x.i_type == .folder {
            print('[]')
        }
        if x.i_type == .zip {
            print('[ZIP]')
        }
        println('${x.path} => ${x.container_index} ${x.container_item_index} ${x.name} ne:${x.need_extract}')
    }
    println('n_item: ${item_list.n_item} index: ${item_list.item_index}')
    println('================================')
}

fn (mut item_list Item_list) get_items_list(args []string) {
    item_list.loaded = false
    println('Args: ${args}')

    item_list.path_sep = $if windows { '\\' } $else { '/' }
    for x in args {
        // scan folder
        if os.is_dir(x) {
            mut item := Item{
                path:            x
                name:            x
                container_index: item_list.lst.len
                i_type:          .folder
            }
            item_list.lst << item
            item_list.scan_folder(x, item_list.lst.len - 1) or {
                eprintln('ERROR: scanning folder [${x}]!')
                continue
            }
        } else {
            mut item := Item{
                path:            ''
                name:            x
                container_index: -1
            }
            ext := get_extension(x)
            // scan .zip
            if ext == .zip {
                item.i_type = .zip
                item_list.lst << item
                item_list.scan_zip(x, item_list.lst.len - 1) or {
                    eprintln('ERROR: scanning zip [${x}]!')
                    continue
                }
                continue
            }
            // single images
            if is_image(ext) == true {
                item_list.n_item += 1
                item.n_item = item_list.n_item
                item.i_type = ext
                item.drawable = true
                item_list.lst << item
                continue
            }
        }
    }
    // debug call for list all the loaded items
    // item_list.print_list()

    println('Items: ${item_list.n_item}')
    println('Scanning done.')

    item_list.get_next_item(1)
    item_list.loaded = true
}

/******************************************************************************
*
* Navigation functions
*
******************************************************************************/
fn (mut item_list Item_list) get_next_item(in_inc int) {
    // if empty exit
    if item_list.lst.len <= 0 || item_list.n_item <= 0 {
        return
    }

    inc := if in_inc > 0 { 1 } else { -1 }
    mut i := item_list.item_index + in_inc
    i = modulo(i, item_list.lst.len)
    start := i
    for {
        if item_list.lst[i].drawable == true {
            item_list.item_index = i
            break
        }
        i = i + inc
        i = modulo(i, item_list.lst.len)
        // if we are in a loop break it
        if i == start {
            break
        }
    }
    // println("Found: ${item_list.item_index}")
}

fn (mut item_list Item_list) go_to_next_container(in_inc int) {
    // if empty exit
    if item_list.lst.len <= 0 || item_list.n_item <= 0 {
        return
    }
    inc := if in_inc > 0 { 1 } else { -1 }
    mut i := item_list.item_index + in_inc
    i = modulo(i, item_list.lst.len)
    start := i
    for {
        // check if we found a folder
        if is_container(item_list.lst[i].i_type) == true
            && i != item_list.lst[item_list.item_index].container_index {
            item_list.item_index = i
            item_list.get_next_item(1)
            break
        }
        // continue to search
        i = i + inc
        i = modulo(i, item_list.lst.len)
        // if we are in a loop break it
        if i == start {
            break
        }
    }
}

/******************************************************************************
*
* Other functions
*
******************************************************************************/
@[inline]
fn (mut item_list Item_list) rotate(in_inc int) {
    item_list.lst[item_list.item_index].rotation += in_inc
    if item_list.lst[item_list.item_index].rotation >= 4 {
        item_list.lst[item_list.item_index].rotation = 0
    }
}