/*
 MU : muto's utility tool.

 TODO:
    password
    delete file on server
*/
package main

import (
    "archive/tar"
    "bufio"
    "bytes"
    "compress/gzip"
    "flag"
    "fmt"
    "io"
    "io/ioutil"
    "log"
    "mime/multipart"
    "net"
    "net/http"
    "os"
    "runtime"
    "strconv"
    "strings"
    "time"

    "./lu"
)

var version = "1.01"

func main() {

    var getfile  = flag.Bool( "g", false, "get a file from site." )                         // ok
    var putfile  = flag.Bool( "G", false, "put a file to site." )                           // ok
    var compupld = flag.Bool( "zu", false, "compress & upload files. (.tgz)" )              // ok
    var compress = flag.Bool( "z",  false, "compress files. ( not upload. )" )              // ok
    var uncmprss = flag.Bool( "x",  false, "uncompress files. (.tgz )" )                    // ok
    var noprefix = flag.Bool( "n", false, "not add prefix(YYYYMMDDhhmm_) to filename." )    // ok

    var wget     = flag.Bool( "w", false, "little wget tool." )                             // ok
    var wc_l     = flag.Bool( "l", false, "little wc -l tool." )                            // ok
    var catn     = flag.Bool( "C", false, "little cat -n tool." )                           // ok
    var reverse  = flag.Bool( "q", false, "little tac tool. ( reverse file )" )             // ok
    var uniq     = flag.Bool( "u",   false, "little uniq tool." )                           // ok
    var uniqc    = flag.Bool( "uc",  false, "little uniq tool.( count )" )                  // ok
    var uniqd    = flag.Bool( "ud",  false, "little uniq tool.( only dup )" )               // ok
    var uniqdc   = flag.Bool( "udc", false, "little uniq tool.( count dup )" )              // ok
    var md5      = flag.Bool( "md5",    false, "md5." )                                     // ok
    var sha256   = flag.Bool( "sha256", false, "sha256." )                                  // ok

    var msleep   = flag.Bool( "M", false, "sleep." )
    //var swatch   = flag.Bool( "W", false, "stop watch." )
    //var bccalc   = flag.Bool( "j", false, "calculator." )
    //var bhole   = flag.Bool( "k", false, "black hole. ( /dev/null )" )
    var cmdtime  = flag.Bool( "T", false, "measure program running time." )
    var touch    = flag.Bool( "t", false, "little touch tool." )
    var replace  = flag.Bool( "r", false, "replace strings. ( s/arg1/arg2/g )" )
    var sort     = flag.Bool( "s", false, "little sort tool." )
    var nsort    = flag.Bool( "ns", false, "little number sort tool." )
    var grep     = flag.Bool( "a", false, "little grep tool." )
    var grepv    = flag.Bool( "b", false, "little grep -v tool." )
    var tree     = flag.Bool( "f", false, "little tree tool." )
    var head     = flag.Int(  "d",     0, "little head/tail tool.( head:n, tail:-n )" )
    //var cut      = flag.String( "c", "", "little cut tool ( only csv )." )
    var migemo   = flag.Bool( "m", false, "migemo tool." )
    //var split    = flag.Int(  "s",   100, "split file ( default 100 MB )." )
    var ipscan   = flag.Bool( "p", false, "ping." )
    var minfo    = flag.Bool( "i", false, "print machine infomation." )                     // half-ok

    //var imgsz    = flag.String( "is", "", "resize image" )
    //var imgconv  = flag.String( "ic", "", "convert image type" )

    var pversion = flag.Bool( "v", false, "print version." )                                // ok
    var help     = flag.Bool( "h", false, "help." )                                         // ok
    flag.Parse()

    if *pversion {
        fmt.Fprintf( os.Stderr, "%s [ ver %s ]\n", os.Args[0], version )
        os.Exit( 0 )
    }

    if *help {
        print_help()
        os.Exit( 0 )
    }

    if *minfo {
        // IP, mask, gw, dns
        host, _ := os.Hostname()
        fmt.Fprintf( os.Stderr, "OS = %s\n", runtime.GOOS )
        fmt.Fprintf( os.Stderr, "ARCH = %s\n", runtime.GOARCH )
        fmt.Fprintf( os.Stderr, "HOSTNAME = %s", host )
        addrs, err := net.InterfaceAddrs()
        if err != nil {
            log.Fatal( err )
        }
        ip := "127.0.0.1"
        for _, addr := range addrs {
            if ipnet, ok := addr.(*net.IPNet); ok && !ipnet.IP.IsLoopback() {
                if ipnet.IP.To4() != nil {
                    ip = ipnet.IP.String()
                }
            }
        }
        fmt.Fprintf( os.Stderr, " [%s]\n", ip )
        os.Exit( 0 )
    }

    /* Here Utility Function ( unix tool like tools ) */
    if *msleep {
        fmt.Fprintln( os.Stderr, "not implement" )
        os.Exit( 3 )
    }

    if *cmdtime {
        fmt.Fprintln( os.Stderr, "not implement" )
        os.Exit( 3 )
    }

    if *wget {  // done.
        if flag.NArg() == 0 {
            fmt.Fprintln( os.Stderr, "no url" )
            os.Exit( 1 )
        }
        url := flag.Args()[0]
        if !strings.Contains( url, "://" ) {
            url = "http://" + url
        }

        fmt.Printf( "%s", url_get( url ) )
        os.Exit( 0 )
    }

        /*
    if *cut {
        fmt.Fprintln( os.Stderr, "not implement" )
        if err := is_exist_files( flag.Args() ); err != nil {
            log.Fatal( err )
        }
        lu.CutCsv( flag.Args() )
        os.Exit( 3 )
    }
        */

    if *sort {
        fmt.Fprintln( os.Stderr, "not implement" )
        os.Exit( 3 )
    }

    if *nsort {
        fmt.Fprintln( os.Stderr, "not implement" )
        os.Exit( 3 )
    }

    if *tree {
        fmt.Fprintln( os.Stderr, "not implement" )
        os.Exit( 3 )
    }

    if *catn {  // done.
        if err := is_exist_files( flag.Args() ); err != nil {
            log.Fatal( err )
        }
        lu.Cat_n( flag.Args() )
        os.Exit( 0 )
    }

    if *wc_l {  // done.
        if err := is_exist_files( flag.Args() ); err != nil {
            log.Fatal( err )
        }
        lu.Wc_l( flag.Args() )
        os.Exit( 0 )
    }

    if *uniq || *uniqc || *uniqd || *uniqdc {   // done.
        if err := is_exist_files( flag.Args() ); err != nil {
            log.Fatal( err )
        }
        if *uniqdc {
            *uniqc, *uniqd = true, true
        }
        lu.Uniq( *uniqc, *uniqd, flag.Args() )
        os.Exit( 0 )
    }

    if *head != 0 {
        fmt.Fprintln( os.Stderr, "not implement" )
        if err := is_exist_files( flag.Args() ); err != nil {
            log.Fatal( err )
        }
        lu.Head( *head, flag.Args() )
        os.Exit( 0 )
    }

    if *reverse {   // done.
        if err := is_exist_files( flag.Args() ); err != nil {
            log.Fatal( err )
        }
        lu.Reverse( flag.Args() )
        os.Exit( 0 )
    }

    if *grep || *grepv {
        if flag.NArg() < 2 {
            fmt.Println( "too ?? argnument." )
            os.Exit( 0 )
        }
        if err := is_exist_files( flag.Args()[1:] ); err != nil {
            log.Fatal( err )
        }
        lu.Grep( flag.Args()[0], *grepv, flag.Args()[1:] )
        os.Exit( 0 )
    }

    if *migemo {
        fmt.Fprintln( os.Stderr, "not implement" )
        os.Exit( 3 )
    }

    if *replace {
        if err := is_exist_files( flag.Args() ); err != nil {
            log.Fatal( err )
        }
        lu.Replace( "", "", flag.Args() )
        os.Exit( 0 )
    }

    if *touch {
        if err := is_exist_files( flag.Args() ); err != nil {
            log.Fatal( err )
        }
        lu.Touch( flag.Args() )
        os.Exit( 0 )
    }

    if *md5 {   // done.
        if err := is_exist_files( flag.Args() ); err != nil {
            log.Fatal( err )
        }
        lu.Md5( flag.Args() )
        os.Exit( 0 )
    }

    if *sha256 {    // done.
        if err := is_exist_files( flag.Args() ); err != nil {
            log.Fatal( err )
        }
        lu.Sha256( flag.Args() )
        os.Exit( 0 )
    }

    if *ipscan {
        fmt.Fprintln( os.Stderr, "not implement" )
        os.Exit( 2 )
    }

    if *uncmprss {  // done.
        if err := is_exist_files( flag.Args() ); err != nil {
            log.Fatal( err )
        }
        lu.UnTgz( flag.Args() )
        os.Exit( 0 )
    }

    /* Here My Uplaad / Download Function */
    host := "http://777.nazo.cc"
    // 引数が指定されたらアップロード
    if *putfile {
        if flag.NArg() > 0 {

            // アップロードには，このプログラムで認証が必要:未実装
            if !is_valid_user() {
                fmt.Println( "wrong password." )
                os.Exit( 0 )
            }

            for _, file := range flag.Args() {
                if _, err := os.Stat( file ); os.IsNotExist( err ) {
                    fmt.Fprintf( os.Stderr, "%s: not exist\n", file )
                }
            }

            url := host + "/uploader/index.cgi/goup/post"
            //url = "http://localhost:3000/gofile"

            var prefix string
            if !*noprefix {
                prefix = time.Now().Format( "200601021504_" )
            }

            // 圧縮
            if *compress || *compupld {
                tmpfile, err := ioutil.TempFile( ".", "muxx" )
                if err != nil {
                    log.Fatal( err )
                }

                if err := archive_compress( tmpfile.Name(), flag.Args() ); err != nil {
                    log.Fatal( err )
                }

                tgz := prefix + tmpfile.Name() + ".tgz"
                os.Rename( tmpfile.Name(), tgz )
                fmt.Printf( "archive & compress ...done [%s].\n", tgz )

                if *compupld {
                    if err := post_file( url, tgz ); err != nil {
                        log.Fatal( err )
                    }
                    fmt.Println( "upload ...done." )
                    defer os.Remove( tgz )
                }
                // 非圧縮
            } else {
                for _, file := range flag.Args() {
                    if !*noprefix {
                        c, err := ioutil.ReadFile( file )
                        if err != nil {
                            log.Fatal( err )
                        }
                        if err := ioutil.WriteFile( prefix + file, c, 0644 ); err != nil {
                            log.Fatal( err )
                        }
                    }
                    if err := post_file( url, prefix + file ); err != nil {
                        log.Fatal( err )
                    }
                    fmt.Println( file + "\tupload ...done." )
                }
            }
            os.Exit( 0 )
        }
    }

    // ファイル一覧を取得
    if *getfile {
        url := host + "/uploader/index.cgi/goup/"
        list := url_get( url )
        files := strings.Split( string( list ), "\n" )

        var filename [100]string
        for i, file := range files {
            info := strings.Split( file, "#" )
            fmt.Printf( "[%3d] %-28s %10s  %s\n", i + 1, info[0], info[1], info[2] )
            filename[i] = info[0]
        }

        fmt.Print( "> " )
        scanner := bufio.NewScanner( os.Stdin )
        scanner.Scan()
        input := scanner.Text()

        if strings.Compare( input, "q" ) == 0 || strings.Compare( input, "bye" ) == 0 {
            fmt.Println( "bye." )
            os.Exit( 0 )
        }

        no, err := strconv.Atoi( input )
        if err != nil || no < 1 || no > len( files ) {
            fmt.Fprint( os.Stderr, "bad input\n" )
            os.Exit( 0 )
        }

        url = host + "/uploader/files/goup/" + filename[ no - 1 ]
        fmt.Printf( "downloading %s...\n", filename[ no - 1 ] )
        bytes := url_get( url )
        if err := ioutil.WriteFile( filename[ no - 1 ], bytes, 0644 ); err != nil {
            log.Fatal( err )
        }
        os.Exit( 0 )
    }

    print_help()
}

// Subroutines
func url_get( url string ) []byte {
    res, err := http.Get( url )
	if err != nil {
		log.Fatal( err )
	}
	b, err := ioutil.ReadAll( res.Body )
	res.Body.Close()
	if err != nil {
		log.Fatal( err )
	}
    return b
}

func post_file( url, file string ) error {

    f, err := os.Open( file )
    if err != nil {
        return err
    }
    defer f.Close()

    buf := &bytes.Buffer{}
    writer := multipart.NewWriter( buf )
    fw, err := writer.CreateFormFile( "filename", file )
    if err != nil {
        return err
    }

    if _, err = io.Copy( fw, f ); err != nil {
        return err
    }

    ct :=  writer.FormDataContentType()
    writer.Close()

    resp, err := http.Post( url, ct, buf )
    if err != nil {
        fmt.Fprintf( os.Stderr, "%s", resp.Status )
        return err
    }

    return nil
}

func is_valid_user() bool {
    return true
    return false
}

func archive_compress( zfile string, files []string ) ( error ) {
    tgz, err := os.Create( zfile )
    if err != nil {
        return err
    }
    defer tgz.Close()

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

    for _, file := range files {
        f, err := os.Open( file )
        if err != nil {
            return err
        }
        defer f.Close()

        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 {
            return err
        }
        if _, err := io.Copy( tw, f ); err != nil {
            return err
        }
    }
    return nil
}

func is_exist_files( files []string ) error {
    for _, file := range files {
        if _, err := os.Stat( file ); os.IsNotExist( err ) {
            return fmt.Errorf( "%s: not exist\n", file )
        }
    }
    return nil
}

func print_help() {
    fmt.Fprintf( os.Stderr, "Usage of %s [%s]:\n", os.Args[0], version )
    flag.PrintDefaults()
}