package main

import (
    "os"
    "log"
    "fmt"
    "io/ioutil"
    "strconv"
    "strings"
    "bufio"
    "io"
    "time"
)

/**
文件目录的创建和删除
 */

func mkdir() {
    err := os.Mkdir("D:\\theWayGo\\src\\gotest\\base-package\\os\\dir1", 0777)
    if err != nil {
        //单层目录创建，重复的时候会报错
        log.Println(err)
    }
    err = os.MkdirAll("D:\\theWayGo\\src\\gotest\\base-package\\os\\dir2\\test", 0777)
    if err != nil {
        //多级目录创建，会安目录一级级创建，但同样的路径，删除的时候要注意路径，删除只会针对路径最后一级，重复创建的时候不会报错
        log.Println(err)
    }
}

func rmdir() {
    //只删除针对的目录
    err := os.Remove("D:\\theWayGo\\src\\gotest\\base-package\\os\\dir1")
    if err != nil {
        //单目录删除的情况下，目录不为空的时候删除会返回异常
        //且目录不存在的时候，删除会返回异常：The system cannot find the file specified.
        log.Println(err.Error())
    }
    //删除目录下所有
    err = os.RemoveAll("D:\\theWayGo\\src\\gotest\\base-package\\os\\dir2")
    if err != nil {
        //目录不存在的情况下，删除也不会返回异常
        log.Println(err.Error())
    }
}

/**
文件的创建
 */
func createFile() {
    file, err := os.Create("D:\\theWayGo\\src\\gotest\\base-package\\os\\dir2\\test.go")
    if err != nil {
        log.Println(err.Error())
    }
    //defer file.Close()
    file.Close()

    //全名：包含路径
    fmt.Println(file.Name())

    //当用defer 的时候，此处删除文件夹是会报错的，文件还未close还处于使用中，不允许删除
    //err = os.RemoveAll("D:\\theWayGo\\src\\gotest\\base-package\\os\\dir2")
    //if err != nil {
    //  log.Println(err.Error())
    //}
}

/**
delete file
 */
func delFile() {
    err := os.Remove("D:\\theWayGo\\src\\gotest\\base-package\\os\\dir2\\test.go")
    if err != nil {
        log.Println(err.Error())
    }
}

/**
read file
 */

//使用ioutil直接读取
//从一个io.Reader类型中读取内容直到返回错误或者EOF时返回读取的数据，当err == nil时，数据成功读取到[]byte中
//ReadAll函数被定义为从源中读取数据直到EOF，它是不会去从返回数据中去判断EOF来作为读取成功的依据
//func ReadAll(r io.Reader) ([]byte, error)

//读取一个目录，并返回一个当前目录下的文件对象列表和错误信息
//func ReadDir(dirname string) ([]os.FileInfo, error)

//读取文件内容，并返回[]byte数据和错误信息。err == nil时，读取成功
//func ReadFile(filename string) ([]byte, error)

func ioutilReadFile() {
    infos, err := ioutil.ReadDir("D:\\theWayGo\\src\\gotest\\base-package\\os\\dir2")
    if err != nil {
        log.Println(err.Error())
    }

    for k, v := range infos {
        fmt.Println(k, v.Name(), v.IsDir(), v.Mode(), v.ModTime(), v.Size(), v.Sys())
    }

    res, err := ioutil.ReadFile("D:\\theWayGo\\src\\gotest\\base-package\\os\\dir2\\ws_erp_20181227.xlsx")
    if err != nil {
        log.Println(err.Error())
    }

    fmt.Println(string(res))
}

//使用os.Open和ioutil.ReadAll读取
//打开一个需要被读取的文件，如果成功读取，返回的文件对象将可用被读取，该函数默认的权限为O_RDONLY，
// 也就是只对文件有只读权限。如果有错误，将返回*PathError类型
//func Open(name string) (*File, error)

//大部分用户会选择该函数来代替Open or Create函数。该函数主要用来指定参数(os.O_APPEND|os.O_CREATE|os.O_WRONLY)
// 以及文件权限(0666)来打开文件，如果打开成功返回的文件对象将被用作I/O操作
//func OpenFile(name string, flag int, perm FileMode) (*File, error)
func ioutilReadAllFile() {

    //file, err := os.Open("D:\\theWayGo\\src\\gotest\\base-package\\os\\dir2\\ws_erp_20181227.xlsx")
    file, err := os.OpenFile("D:\\theWayGo\\src\\gotest\\base-package\\os\\dir2\\ws_erp_20181227.xlsx", os.O_RDONLY, 0666)
    if err != nil {
        log.Println(err.Error())
    }

    defer file.Close()

    body, err := ioutil.ReadAll(file)
    if err != nil {
        log.Println(err.Error())
    }

    fmt.Println(string(body))
}

//借助os.Open进行读取文件(打开文件获取的对象自带的方法)
func openReadFile() {
    if file, err := os.Open(""); err == nil {
        defer file.Close()

        //在定义空的byte列表时尽量大一些，否则这种方式读取内容可能造成文件读取不完整
        buf := make([]byte, 1024)
        if n, err := file.Read(buf); err == nil {
            fmt.Println("The number of bytes read:"+strconv.Itoa(n), "Buf length:"+strconv.Itoa(len(buf)))
            result := strings.Replace(string(buf), "\n", "", 1)
            fmt.Println("Use os.Open and File's Read method to read a file:", result)
        }
    }
}

//使用os.Open和bufio.Reader读取文件内容:带缓存的读取
func bufioReadFile() {
    file, err := os.Open("D:\\theWayGo\\src\\gotest\\base-package\\os\\dir2\\ws_erp_20181227.xlsx")
    if err != nil {
        log.Println(err.Error())
    }

    buf := bufio.NewReader(file)
    for {
        //单行的读取，需要循环读取
        //todo buf的读取方式有很多，后续可以参照文档练习，并跟需求场景选择合适的方法
        res, err := buf.ReadBytes('\n')
        if err == io.EOF {
            time.Sleep(time.Second)
        } else if err != nil {
            log.Println(err.Error())
            panic(err.Error())
        }
        if len(res) <= 0 {
            continue
        }
        fmt.Println(len(res), string(res))
    }
}

/**
write file
 */

//使用ioutil包进行文件写入
func ioutilWrite() {
    content := "大道至简"
    err := ioutil.WriteFile("D:\\theWayGo\\src\\gotest\\base-package\\os\\dir2\\go.txt", []byte(content), 0777)
    if err != nil {
        log.Println("write fail")
        panic(err.Error())
    }
}

//使用os.OpenFile相关函数进行文件写入
func openWrite() {
    file, err := os.OpenFile("D:\\theWayGo\\src\\gotest\\base-package\\os\\dir2\\go.txt", os.O_RDWR|os.O_CREATE, 0777)
    if err != nil {
        log.Println(err.Error())
        panic(err.Error())
    }

    defer file.Close()

    file.Seek(0, 2)
    content := []byte("Go 会是转折点么？")
    _, err = file.Write(content)
    if err != nil {
        log.Println(err.Error())
        panic(err.Error())
    }
}

//使用bufio包中的相关函数写入文件
func bufioWrite() {
    file, err := os.OpenFile("D:\\theWayGo\\src\\gotest\\base-package\\os\\dir2\\go.txt", os.O_RDWR|os.O_CREATE, 0777)
    if err != nil {
        log.Println(err.Error())
        panic(err.Error())
    }

    defer file.Close()

    file.Seek(0,2)
    content := []byte("但行好事莫问前程，自顾向前何愁天不怜")

    //使用NewWriter方法返回的io.Writer缓冲默认大小为4096，也可以使用NewWriterSize方法设置缓存的大小
    buf := bufio.NewWriter(file)

    //将文件写入缓存
    _, err = buf.Write(content)
    if err != nil {
        log.Println(err.Error())
        panic(err.Error())
    }

    //从缓存写入到文件中
    if err = buf.Flush();err != nil{
        log.Println(err.Error())
        panic(err.Error())
    }
}

func main() {
    //mkdir()
    //rmdir()
    //createFile()
    //delFile()
    //ioutilReadFile()
    //ioutilReadAllFile()
    //bufioReadFile()
    //ioutilWrite()
    //openWrite()
    bufioWrite()
}