#include <rtdbg.h>
#include <stdio.h>
#include <unistd.h>
#include <rtdevice.h>
#include <rtthread.h>
#include <dfs_posix.h>
#include <dfs_romfs.h>
#include "datadef.h"
#include "fal.h"
#include "fs.h"
#include "log.h"



#define MALLOC   malloc
#define FREE     free


static const struct romfs_dirent _romfs_root[] =
{
    {ROMFS_DIRENT_DIR, SD_DEV,  RT_NULL, 0},
    {ROMFS_DIRENT_DIR, NOR_DEV, RT_NULL, 0},
};
static const struct romfs_dirent romfs_root =
{
    ROMFS_DIRENT_DIR, "/", (rt_uint8_t *)_romfs_root, sizeof(_romfs_root) / sizeof(_romfs_root[0])
};

typedef struct {
    uint8_t  mounted[FS_DEV_MAX];
    
}fs_handle_t;
static fs_handle_t fsHandle={0};

typedef struct {
    uint8_t id;
    char *dev;
    char *mpath;
    char *ftype;
}mnt_info_t;


static mnt_info_t MNT_INFO[FS_DEV_MAX]={
    {FS_DEV_SD,  SD_DEV,  SD_PATH,  "elm"},
    {FS_DEV_NOR, NOR_DEV, NOR_PATH, "elm"},
};

static int sd_mount(void)
{
    int r=1,n=0;
    while(n<10) {
        r = mmcsd_wait_cd_changed(500);
        if(r==MMCSD_HOST_PLUGED) {
            r = fs_mount(SD_DEV, 1);
        }
        else if(r==MMCSD_HOST_UNPLUGED) {
            r = fs_mount(SD_DEV, 0);
        }
        
        if(r<=0) break;
        n++;
    }
    return r;
}
static int nor_mount(void)
{
    int r=0;
    struct rt_device *dev = RT_NULL;
    
    fal_init();
    
    dev = fal_blk_device_create(NOR_DEV);
    if(!dev) {
        LOGE("Can't create a mtd device on nor partition\n");
        return -1;
    }
    
    r = fs_mount(NOR_DEV, 1);
    return r;
}


static int is_mounted(fs_handle_t *h, char *dev, char *path)
{
    int i;
    for(i=0; i<FS_DEV_MAX; i++) {
        if(dev) {
            if(strcmp(dev, MNT_INFO[i].dev)==0) {
                return h->mounted[i];
            }
        }
        
        if(path) {
            if(strstr(path, MNT_INFO[i].mpath)) {
                return h->mounted[i];
            }
        }
    }
    return 0;
}
static mnt_info_t* get_info(fs_handle_t *h, char *dev)
{
    int i;
    for(i=0; i<FS_DEV_MAX; i++) {
        if(strcmp(dev, MNT_INFO[i].dev)==0) {
            return &MNT_INFO[i];
        }
    }
    return NULL;
}
static int dfs_mounts(const char *dev, const char *path, const char *fs_type)
{
    char *p=(char*)path;
    int r=0,len=strlen(path);
    
    if(len>1) {
        p = strchr(path+1, '/');
    }
    while(p) {
        if(p>path) *p = 0;
        r = dfs_mount(dev, path, fs_type, 0, 0);
        LOGD("___ %s mount %s!\n", path, r?"failed":"ok");
        if(p>path) *p = '/';
        
        p = strchr(p+1, '/');
        if(r) break;
    }
    return r;
}
static int do_mount(fs_handle_t *h, char *dev, int flag)
{
    int r=0;
    rt_err_t err=0;
    mnt_info_t *info=NULL;
    rt_device_t pdev=NULL;
    
    info = get_info(h, dev);
    if(!info) {
        return -1;
    }
    
    //flag>0表示挂载, 若已经挂载则退出
    if(flag && h->mounted[info->id]) {
        return 0;
    }
    
    //flag=0表示卸载, 若已经已经卸载则退出
    if(!flag && !h->mounted[info->id]) {
        return 0;
    }
        
    pdev = rt_device_find(info->dev);
    if(pdev) {
        if(flag) {
            r = dfs_mount(info->dev, info->mpath, info->ftype, 0, 0);
            if (r) {
                dfs_mkfs(info->dev, info->ftype);
                r = dfs_mount(info->dev, info->mpath, info->ftype, 0, 0);
                if(r==0) {
                    h->mounted[info->id] = 1;
                }
                else {
                    LOGD("%s mount failed\n", info->mpath);
                }
            }
            else {
                LOGD("%s mount ok!\n", info->mpath);
            }
        }
        else {
            r = dfs_umount(info->mpath, 0);
        }
    }
    
    return r;
}

int fs_mount(char *dev, int flag)
{
    fs_handle_t *h=&fsHandle;
    return do_mount(h, dev, flag);
}

int fs_test(void)
{
    int r;
    buf_t fbuf;
    char *dev="sd";
    #define MNT_PATH "/"
    char *fpath=MNT_PATH"text.txt";
    char *ttt="hello every one!";
    rt_device_t devid=NULL;
    static int mounted=0;
    
    if(!fs_exist(fpath)) {
        r = fs_save(fpath, ttt, strlen(ttt)+1);
        r = fs_load(fpath, &fbuf);
        if(r==0) {
            rt_kprintf("_____\n");
        }
    }
    
    return 0;
}


int fs_mkdir(char *path)
{
    char tmp[256];
    char *p = NULL;
    size_t len;
    mode_t mode=0x777;
 
    snprintf(tmp, sizeof(tmp),"%s", path);
    len = strlen(tmp);
    if(tmp[len - 1] == '/')
        tmp[len - 1] = 0;
    
    for(p = tmp + 1; *p; p++) {
        if(*p == '/') {
            *p = 0;
            if(access(tmp, F_OK)==-1) {
                if (mkdir(tmp, mode) == -1) {
                    if (errno != EEXIST) return -1;
                }
            }
            *p = '/';
        }
    }
    return mkdir(tmp, mode);
}


int fs_init(void)
{
    dfs_mount(NULL, "/", "rom", 0, &(romfs_root));
    sd_mount();
    nor_mount();
    return 0;
}


int fs_length(char* path)
{
    int r;
    struct stat st;
    fs_handle_t *h=&fsHandle;

    r = stat(path, &st);
    if (r) {
        return -1;
    }

    return st.st_size;
}


int fs_exist(char* path)
{
    int r=0;
    if(access(path, F_OK)!=-1) {
        r = 1;
    }

    return r;
}


int fs_save(char *path, void *buf, int len)
{
    int r;
    FILE *fp=NULL;
    char *p=strrchr(path, '/');
    
    if(p) {
        *p = 0;
        r = fs_mkdir(path);
        *p = '/';
    }
    
    fp = fopen(path, "w");
    if(!fp) {
        LOGE("file_save, fopen %s failed\n", path);
        return -1;
    }
    
    r = fwrite(buf, 1, len, fp);
    if(r!=len) {
        LOGE("file_save %s failed, %d, %d\n", path, r, len);
        r = -1;
    }
    else {
        r = 0;
    }
    fclose(fp);

    return r;
}

int fs_load(char* path, buf_t *fbuf)
{
    int r,flen,blen;
    FILE* fp;

    flen = fs_length(path);
    if(flen<=0) {
        LOGE("____ file_load, %s failed\n", path);
        return -1;
    }

    blen = flen+1;
    fbuf->buf = (char*)MALLOC(blen);
    if(!fbuf->buf) {
        LOGE("____ file_load, %s malloc %d failed\n", path, flen);
        return -1;
    }
    fbuf->dlen = flen;
    fbuf->blen = blen;

    fp = fopen(path, "r");
    if (!fp) {
        LOGE("file_load, fopen %s failed\n", path);;
        FREE(fbuf->buf);
        return -1;
    }
    r = fread(fbuf->buf, 1, flen, fp);
    if (r != flen) {
        LOGE("file_load %s failed, %d, %d\n", path, r, flen);
        fclose(fp); FREE(fbuf->buf);
        r = -1;
    }
    else {
        fbuf->buf[flen] = 0; r = 0;
    }
    fclose(fp);

    return r;
}


char* fs_load2(char* path, int add0)
{
    FILE* fp=NULL;
    int r,flen,blen;
    char *fbuf=NULL;

    flen = fs_length(path);
    if(flen<=0) {
        LOGE("____ file_load2, %s failed\n", path);
        return NULL;
    }

    blen = flen+(add0?1:0);
    fbuf = (char*)MALLOC(blen);
    if(!fbuf) {
        LOGE("____ file_load2, %s malloc %d failed\n", path, flen);
        return NULL;
    }

    fp = fopen(path, "r");
    if (!fp) {
        LOGE("file_load2, fopen %s failed\n", path);;
        FREE(fbuf);
        return NULL;
    }
    r = fread(fbuf, 1, flen, fp);
    if (r != flen) {
        LOGE("file_load2 %s failed, %d, %d\n", path, r, flen);
        fclose(fp); FREE(fbuf);
        fbuf = NULL;
    }
    if(add0) fbuf[flen] = 0;
    fclose(fp);

    return fbuf;
}


int fs_copy(char *dst, char *src)
{
    int r;
    buf_t fbuf;

    remove(dst);
    r = fs_load(src, &fbuf);
    if(r==0) {
        r = fs_save(dst, fbuf.buf, fbuf.dlen);
        free(fbuf.buf);
    }

    return r;
}


int fs_remove(char *path)
{
    return remove(path);
}


int fs_append(char *path, void *data, int datalen)
{
    int r=-1;
    FILE* fp;

    fp = fopen(path, "a");
    if(!fp) {
        LOGE("file_append, fopen %s failed\n", path);
        return -1;
    }
    r = fwrite(data, 1, datalen, fp);
    if(r==datalen) {
        r = 0;
    }
    else {
        LOGE("file_append %s failed, %d, %d\n", path, r, datalen);
    }
    fclose(fp);

    return r;
}