/*
    little unix tool library.
*/
package lu

import (
    "archive/tar"
    "bufio"
    "bytes"
    "compress/gzip"
    "crypto/md5"
    "crypto/sha256"
    "fmt"
    "io"
    "log"
    "os"
    "os/exec"
    "path/filepath"
    "regexp"
    "strings"
)

func CmdTime( cmdline string ) {
    cmd := exec.Command( "ls", "-l" )
	cmd.Stdin = strings.NewReader( "some input" )
	var out bytes.Buffer
	cmd.Stdout = &out
	err := cmd.Run()
	if err != nil {
		log.Fatal( err )
	}
	fmt.Printf( "%q\n", out.String() )
}

/* cut -d, -f: */
func CutCsv( files []string, cols []string ) {
}

/* cat -n: done. */
func Cat_n( files []string ) {
    if len( files ) == 0 {
        cnt := 1
        input := bufio.NewScanner( os.Stdin )
        for input.Scan() {
            fmt.Printf( "%5d  %s\n", cnt, input.Text() )
            cnt++
        }
    } else {
        for _, file := range files {
            cnt := 1
            f, _ := os.Open( file )
            input := bufio.NewScanner( f )
            for input.Scan() {
                fmt.Printf( "%5d  %s\n", cnt, input.Text() )
                cnt++
            }
            f.Close()
        }
    }
}

/* wc -l: done. */
func Wc_l( files []string ) {
    if len( files ) == 0 {
        cnt := 0
        input := bufio.NewScanner( os.Stdin )
        for input.Scan() {
            cnt++
        }
        fmt.Printf( "%d\n", cnt )
    } else {
        for _, file := range files {
            cnt := 0
            f, _ := os.Open( file )
            input := bufio.NewScanner( f )
            for input.Scan() {
                cnt++
            }
            f.Close()
            fmt.Printf( "%s:\t%5d\n", file, cnt )
        }
    }
}

/* tar cvfz: done. */
func Tgz( tgzfile string, files []string ) {

    tgz, err := os.Create( tgzfile )
    if err != nil {
        log.Fatal( err )
    }
    defer tgz.Close()

    gw := gzip.NewWriter( tgz )
    defer gw.Close()
    tw := tar.NewWriter( gw )
    defer tw.Close()

    for _, file := range fullpath( files ) {
        f, err := os.Open( file )
        if err != nil {
            log.Fatal( err )
        }

        stat, _ := f.Stat()
        header := new( tar.Header )
        header.Name = file
        header.Size = stat.Size()
        header.Mode = int64( stat.Mode() )
        header.ModTime = stat.ModTime()

        if err := tw.WriteHeader( header ); err != nil {
            log.Fatal( err )
        }
        if _, err := io.Copy( tw, f ); err != nil {
            log.Fatal( err )
        }
        f.Close()
    }
}

/* tar xvfz: done. */
func UnTgz( files []string ) {

    for _, file := range files {

        f, err := os.Open( file )
        if err != nil {
            log.Fatal( err )
        }
        zr, err := gzip.NewReader( f )
        if err != nil {
            log.Fatal( err )
        }

        tr := tar.NewReader( zr )

        for {
            hdr, err := tr.Next()
            if err == io.EOF {
                break // End of archive
            }
            if err != nil {
                log.Fatal( err )
            }
            fmt.Printf( "%s\n", hdr.Name )

            dir := filepath.Dir( hdr.Name )
            if ( dir != "" ) {
                os.MkdirAll( dir, 0744 )
            }
            f, err := os.OpenFile( hdr.Name, os.O_RDWR|os.O_CREATE, 0644 )
            if err != nil {
                log.Fatal( err )
            }
            if _, err := io.Copy( f, tr ); err != nil {
                log.Fatal( err )
            }

            if err := f.Close(); err != nil {
                log.Fatal( err )
            }
        }

        if err := zr.Close(); err != nil {
            log.Fatal( err )
        }
    }
}

func fullpath( files []string ) []string {
    var buf []string
    for _, f := range files {
        fi, _ := os.Stat( f )
        if fi.IsDir() {
            filepath.Walk( f, func( path string, info os.FileInfo, err error ) error {
                if !info.IsDir() {
                    buf = append( buf, path )
                }
                return nil
            } )
        } else {
            buf = append( buf, f )
        }
    }
    return buf
}

/* tac: done. */
func Reverse( files []string ) {
    var buf []string
    if len( files ) == 0 {
        input := bufio.NewScanner( os.Stdin )
        for input.Scan() {
            buf = append( buf, input.Text() )
        }
    } else {
        for _, file := range files {
            f, _ := os.Open( file )
            input := bufio.NewScanner( f )
            for input.Scan() {
                buf = append( buf, input.Text() )
            }
            f.Close()
        }
    }
    for i := len( buf ); i > 0; i-- {
        fmt.Println( buf[i-1] )
    }
}

/* grep: done. */
func Grep( word string, inv bool, files []string ) {
    regex, err := regexp.Compile( word )
    if err != nil {
        log.Fatal( err )
    }
    if len( files ) == 0 {
        grep( regex, inv, os.Stdin )
    } else {
        for _, file := range files {
            f, _ := os.Open( file )
            grep( regex, inv, f )
            f.Close()
        }
    }
}

func grep( regex *regexp.Regexp, inv bool, r io.Reader ) {
    input := bufio.NewScanner( r )
    for input.Scan() {
        if regex.MatchString( input.Text() ) && !inv {
            fmt.Println( input.Text() )
        }
        if !regex.MatchString( input.Text() ) && inv {
            fmt.Println( input.Text() )
        }
    }
}

/* orgrep: done. */
func OrGrep( lfile string, inv bool, files []string ) {
    var keywords []regexp.Regexp
    f, _ := os.Open( lfile )
    input := bufio.NewScanner( f )
    for input.Scan() {
        regex, err := regexp.Compile( input.Text() )
        if err != nil {
            log.Fatal( err )
        }
        keywords = append( keywords, *regex )
    }
    f.Close()

    if len( files ) == 0 {
        orgrep( keywords, inv, os.Stdin )
    } else {
        for _, file := range files {
            f, _ := os.Open( file )
            orgrep( keywords, inv, f )
            f.Close()
        }
    }
}

func orgrep( keywords []regexp.Regexp, inv bool, r io.Reader ) {
    input := bufio.NewScanner( r )
    seen := make( map[string]bool )
    for input.Scan() {
        for _, r := range keywords {
            if r.MatchString( input.Text() ) {
                seen[ input.Text() ] = true
            }
        }
        if !inv && seen[ input.Text() ] {
            fmt.Println( input.Text() )
        }
        if inv && !seen[ input.Text() ] {
            fmt.Println( input.Text() )
        }
        seen[ input.Text() ] = false
    }
}

/* uniq: done. */
func Uniq( cnt, dup bool, files []string ) {
    var lines []string
    lcnt := make( map[string]int )
    lpnt := make( map[string]bool )

    if len( files ) == 0 {
        input := bufio.NewScanner( os.Stdin )
        for input.Scan() {
            lines = append( lines, input.Text() )
            lcnt[ input.Text() ]++
        }
    } else {
        for _, file := range files {
            f, _ := os.Open( file )
            input := bufio.NewScanner( f )
            for input.Scan() {
                lines = append( lines, input.Text() )
                lcnt[ input.Text() ]++
            }
            f.Close()
        }
    }

    for _, line := range lines {
        if !lpnt[ line ] {
            if dup && lcnt[ line ] == 1 {
                continue
            }
            if cnt {
                fmt.Printf( "%5d  ,", lcnt[ line ] )
            }
            fmt.Printf( "%s\n", line )
            lpnt[ line ] = true
        }
    }
}

func Head( n int, files []string ) {
    if n > 0 {
        if len( files ) == 0 {
            input := bufio.NewScanner( os.Stdin )
            for input.Scan() {
                fmt.Println( input.Text() )
                n--
                if n == 0 {
                    return
                }
            }
        } else {
            for _, file := range files {
                if n == 0 {
                    return
                }
                f, _ := os.Open( file )
                input := bufio.NewScanner( f )
                for input.Scan() {
                    fmt.Println( input.Text() )
                    n--
                    if n == 0 {
                        break
                    }
                }
                f.Close()
            }
        }
    } else {
        if len( files ) == 0 {

        } else {

        }
    }
}

/* replace:  done. */
func Replace( s, t string, files []string ) {
    if len( files ) == 0 {
        input := bufio.NewScanner( os.Stdin )
        for input.Scan() {
            str := strings.Replace( input.Text(), s, t, -1 )
            fmt.Println( str )
        }
    } else {
        for _, file := range files {
            f, _ := os.Open( file )
            input := bufio.NewScanner( f )
            for input.Scan() {
                str := strings.Replace( input.Text(), s, t, -1 )
                fmt.Println( str )
            }
            f.Close()
        }
    }
}

/* touch:  */
func Touch( files []string ) {
    for _, file := range files {
        f, _ := os.Open( file )
        f.Close()
    }
}

/* md5: done. */
func Md5( files []string ) {
    for _, file := range files {
        f, _ := os.Open( file )
        h := md5.New()
        if _, err := io.Copy( h, f ); err != nil {
            log.Fatal( err )
        }
        f.Close()
        if len( files ) == 1 {
            fmt.Printf( "%x\n", h.Sum( nil ) )
        } else {
            fmt.Printf( "%s:\t%x\n", file, h.Sum( nil ) )
        }
    }
}

/* sha256: done.  */
func Sha256( files []string ) {
    for _, file := range files {
        f, _ := os.Open( file )
        h := sha256.New()
        if _, err := io.Copy( h, f ); err != nil {
            log.Fatal( err )
        }
        f.Close()
        if len( files ) == 1 {
            fmt.Printf( "%x\n", h.Sum( nil ) )
        } else {
            fmt.Printf( "%s:\t%x\n", file, h.Sum( nil ) )
        }
    }
}

/* tee: done. */
func Tee( file string ) {
    if _, err := os.Stat( file ); !os.IsNotExist( err ) {
        if err := os.Remove( file ); err != nil {
            log.Fatal( err )
        }
    }
    f, err := os.OpenFile( file, os.O_RDWR|os.O_CREATE, 0644 )
    if err != nil {
        log.Fatal( err )
    }
    defer f.Close()

    w := io.MultiWriter( f, os.Stdout )
    if _, err := io.Copy( w, os.Stdin ); err != nil {
        log.Fatal( err )
    }
}