export interface IStorage {

    readonly type: StorageType;
    /**
     * 获取 string 类型
     */
    readonly get: (name: string) => Promise<string>;
    /**
     * 获取 json 类型
     */
    readonly getJson: <T>(name: string) => Promise<T>;
    /**
     * 写入 string 类型
     */
    readonly set: (name: string, value: string) => void;
    /**
     * 写入 json 类型
     */
    readonly setJson: <T>(name: string, value: T) => void;
    /**
     * 根据名称 删除
     */
    readonly remove: (name: string) => void;
    /**
     * 初始化
     */
    readonly init: (params?: StorageInitParams[]) => void;
}

/**
 * 类型
 */
export type StorageType = {
    readonly get: "get",
    readonly set: "set",
    readonly getJson: "getJson",
    readonly setJson: "setJson",
}

export type StorageInitParams = {
    name: string,
    type: string,
    value: any,
}

/**
 * -------------------------------------------          IStorageData
 */
export interface IStorageDataClass<T> {
    new(params: IStorageDataParams): IStorageData<T>;
}

export interface IStorageData<T> {
    readonly get: () => T;
    readonly add: (params: T) => T;
    readonly update: (params: T) => T;
    readonly remove: () => void;
    readonly storage: (data: T) => void;
    readonly redux: (data: T) => void;
}


export type IStorageDataParams = {
    name: string
    //  是否加入持久化缓存
    hasStorage?: boolean
}

/**
 * -------------------------------------------          IStorageArray
 */

export interface IStorageArrayClass<T> {
    new(params: IStorageArrayParams): IStorageArray<T>;
}

export type IStorageArrayParams = {
    readonly name: string
    //  是否加入持久化缓存
    hasStorage?: boolean
}

export interface IStorageArray<T> {
    readonly query: () => T[];
    readonly queryByParams: (params: T) => T[];
    readonly get: (id: string) => T;
    readonly getByParams: (params: T) => T;
    readonly add: (data: T, isFirst?: boolean) => T;
    readonly addList: (list: T[], isFirst?: boolean) => T[];
    readonly addAll: (list: T[]) => T[];
    readonly update: (id: string, data: T) => T;
    readonly updateByParams: (params: T, data: T) => T[];
    readonly delete: (id: string) => T[];
    readonly deleteByIds: (ids: string[]) => T[];
    readonly remove: () => T[];
    readonly storage: (data: T[]) => void;
    readonly redux: (data: T[]) => void;
}