package volume

import (
    "os"
    "path/filepath"
    "strconv"
    "sync"
    "time"
    "encoding/binary"
    "errors"
)

var (
    TruncateSize uint64 = 1 << 30 //1GB
    MaxVolumeSize uint64 = 512 * TruncateSize //512GB
)

type Volume struct {
    Id        uint64
    WriteAble bool
    index     Index
    status    *Status
    dataFile  *os.File
    mutex     sync.Mutex
}
//创建一个卷 或者磁盘空间   
func NewVolume(dir string, vid uint64) (v *Volume, err error) {
    path := filepath.Join(dir, strconv.FormatUint(vid, 10) + ".data")
    v = new(Volume)
    v.Id = vid
    v.dataFile, err = os.OpenFile(path, os.O_CREATE | os.O_RDWR, 0666)
    if err != nil {
        if os.IsPermission(err) {//判断是不是权限错误
            v.dataFile, err = os.OpenFile(path, os.O_RDONLY, 0)
            if err != nil {
                return nil, err
            }
            v.WriteAble = false
        } else {
            return nil, err
        }
    }
    v.WriteAble = true

    v.index, err = NewLevelDBIndex(dir, vid)
    if err != nil {
        return nil, err
    }

    v.status, err = NewStatus(dir, vid)
    if err != nil {
        return nil, err
    }

    return v, nil
}
//实现index接口
//
func (v *Volume)Get(fid uint64) (*File, error) {
    fi, err := v.index.Get(fid)
    if err == nil {
        return &File{DataFile: v.dataFile, Info: fi}, nil
    } else {
        return nil, err
    }
}
//删除文件
func (v *Volume)Delete(fid uint64, fileName string) error {
    v.mutex.Lock()
    defer v.mutex.Unlock()
    file, err := v.Get(fid)
    if err != nil {
        return err
    } else if file.Info.FileName != fileName {
        return errors.New("filename is wrong")
    }
    //因为文件内容前后都写入fid(8 byte) 要一起释放
    err = v.status.freeSpace(file.Info.Offset - 8, file.Info.Size + 16)
    if err != nil {
        return err
    }
    err = v.index.Delete(fid)
    return err
}
//创建文件
func (v *Volume)NewFile(fid uint64, fileName string, size uint64) (f *File, err error) {
    v.mutex.Lock()
    defer v.mutex.Unlock()
    if v.index.Has(fid) {
        return nil, errors.New("fid is existed")
    }
    offset, err := v.newSpace(size + 16)
    if err != nil {
        return nil, err
    }
    defer func() {
        if err != nil {
            if e := v.status.freeSpace(offset, size + 16); e != nil {
                panic(e)
            }
        }
    }()
    //在文件内容前后都写入fid
    b := make([]byte, 8)
    binary.BigEndian.PutUint64(b, fid)
    _, err = v.dataFile.WriteAt(b, int64(offset))
    if err != nil {
        return nil, err
    }
    _, err = v.dataFile.WriteAt(b, int64(offset + 8 + size))
    if err != nil {
        return nil, err
    }
    fileInfo := &FileInfo{
        Fid: fid,
        Offset: offset + 8,
        Size: size,
        Ctime: time.Now(),
        Mtime: time.Now(),
        Atime: time.Now(),
        FileName: fileName,
    }
    err = v.index.Set(fileInfo)
    if err != nil {
        return nil, err
    } else {
        return &File{DataFile: v.dataFile, Info: fileInfo}, nil
    }
}
//清空文件空间
func (v *Volume)truncate() {
    currentDatafileSize := v.GetDatafileSize()
    if currentDatafileSize >= MaxVolumeSize {
        return
    }
       //清空指定偏移量位置的数据
    err := v.dataFile.Truncate(int64(currentDatafileSize) + int64(TruncateSize))
    if err != nil {
        panic(err)
    }
       //释放文件空间
    err = v.status.freeSpace(currentDatafileSize, TruncateSize)
    if err != nil {
        panic(err)
    }
}
//分配新的文件空间
func (v *Volume)newSpace(size uint64) (uint64, error) {
    offset, err := v.status.newSpace(size)
    if err == nil {
        return offset, err
    }
    v.truncate()
    return v.status.newSpace(size)
}
//资源释放
func (v *Volume)Close() {
    v.mutex.Lock()
    //v.status.spaceMutex.Lock()
    //因为要退出,所以不解锁,禁止读写
    //defer v.rwMutex.Unlock()

    //将所有资源释放
    v.dataFile.Close()
    v.dataFile = nil

    v.status.db.Close()
    v.status = nil

    v.index.Close()
    v.index = nil
}
//获取数据文件大小
func (v *Volume)GetDatafileSize() uint64 {
    fi, err := v.dataFile.Stat()
    if err != nil {
        panic(err)
    }
    return uint64(fi.Size())
}
//获取最大释放文件空间
func (v *Volume)GetMaxFreeSpace() uint64 {
    currentDatafileSize := v.GetDatafileSize()
    //以块方式存储,所以自由空间无法直接相加
    maxFreeSpace := v.status.getMaxFreeSpace()
    if currentDatafileSize < MaxVolumeSize {
        freeSpace := MaxVolumeSize - currentDatafileSize
        if freeSpace > maxFreeSpace {
            maxFreeSpace = freeSpace
        }
    }
    //fid前后各占8个字节
    if maxFreeSpace > 16 {
        return maxFreeSpace - 16
    } else {
        return 0
    }
}