#ifndef STUDY_TIMER_RESOLVER_H
#define STUDY_TIMER_RESOLVER_H
#include "time_util.h"
#include "../util/str_util.h"
#include "assertmy.h"
#include <stdio.h>
#include <stdlib.h>
//秒,分鐘,小時(shí),天,星期,月,年,執(zhí)行計(jì)劃      -,-,-,-,-,-,-,-      代表0秒,0分,0小時(shí),0天,星期,0月,0年,不執(zhí)行
typedef struct timer_resolver {
    char *second;//秒 0-59
    char *minute;//分鐘 0-59
    char *hour; //小時(shí)0-23
    char *day;  //天 1-31
    char *week;//星期 0-6
    char *month;//月份 1-12
    char *year;//年
    char *plan;//執(zhí)行計(jì)劃 -代表不執(zhí)行,n 循環(huán)執(zhí)行,數(shù)字代表執(zhí)行次數(shù) , ^n 階級(jí)執(zhí)行(^1 表示一階執(zhí)行,^2 表示二階執(zhí)行,^3 表示三階執(zhí)行...^n表示n階執(zhí)行)  mode 代表執(zhí)行模式 mode2 代表模式執(zhí)行2次....
    long timestamp;//時(shí)間戳 用于計(jì)算下次執(zhí)行時(shí)間
    char *help;//協(xié)助計(jì)算的字段
    CharHashMap *mode;//模式

} TimerResolver;

typedef  int  (*ModeMethod)(char *item,int seat,TimerResolver *timerResolver); //自定義模式方法
TimerResolver *create_timer_resolver(char *time);
void print_timer_resolver(TimerResolver *timerResolver);
long resolver(TimerResolver *timerResolver);
void switchStructure(TimerResolver *timerResolver);
void add_timer_mode(TimerResolver *timerResolver, char *key, ModeMethod method);
void print_format_resolver(TimerResolver *timerResolver, int n);
#endif //STUDY_TIMER_RESOLVER_H

#include "timer_resolver.h"
char *get_return_data(char **data1);

//獲取以當(dāng)前時(shí)間后指定年月日時(shí)分秒
long time_point_mode(char *item, int seat, TimerResolver *timerResolver) {
    //解析point(?)模式,取出?的值
    int i = str_find(item, "(");
    item = str_substring(item, i + 1, str_length(item) - 2);
    if (seat == 0) { //加秒數(shù)
        return get_next_time_by_timestamp(timerResolver->timestamp, 0, 0, 0, 0, 0, str_to_int(item));
    } else if (seat == 1) { //分鐘數(shù)
        return get_next_time_by_timestamp(timerResolver->timestamp, 0, 0, 0, 0, str_to_int(item), 0);
    } else if (seat == 2) { //小時(shí)數(shù)
        return  get_next_time_by_timestamp(timerResolver->timestamp, 0, 0, 0, str_to_int(item), 0, 0);
    } else if (seat == 3) { //天數(shù)
        return get_next_time_by_timestamp(timerResolver->timestamp, 0, 0, str_to_int(item), 0, 0, 0);
    } else if (seat == 4) { //周n的日期
        return get_next_week_of_day(timerResolver->timestamp, str_to_int(item));
    } else if (seat == 5) { //月數(shù)
        return get_next_time_by_timestamp(timerResolver->timestamp, 0, str_to_int(item), 0, 0, 0, 0);
    } else if (seat == 6) { //年數(shù)
        return get_next_time_by_timestamp(timerResolver->timestamp, str_to_int(item), 0, 0, 0, 0, 0);
    }
}

// 判斷指定時(shí)間,初的時(shí)間
long time_begin_mode(char *item, int seat, TimerResolver *timerResolver) {
    if (seat == 0) { //秒數(shù)
        return get_start_time_of_next_second(timerResolver->timestamp);
    } else if (seat == 1) { //分鐘數(shù)
        return get_start_time_of_next_minute(timerResolver->timestamp);
    } else if (seat == 2) { //小時(shí)數(shù)
        return get_start_time_of_next_hour(timerResolver->timestamp);
    } else if (seat == 3) {// 天數(shù)
        return get_start_time_of_next_day(timerResolver->timestamp);
    } else if (seat == 4) {// 星期數(shù)
        return get_time_next_week_start(timerResolver->timestamp);
    } else if (seat == 5) {// 月數(shù)
        return get_start_time_of_next_month(timerResolver->timestamp);
    } else if (seat == 6) {// 年數(shù)
        return get_start_time_of_next_year(timerResolver->timestamp);
    }
}

// 判斷指定時(shí)間,末的時(shí)間
long time_end_mode(char *item, int seat, TimerResolver *timerResolver) {
    if (seat == 0) { //秒數(shù)
        return timerResolver->timestamp+59;
    } else if (seat == 1) { //分鐘數(shù)(如果當(dāng)前時(shí)間是59秒,則返回下一分鐘的59秒)
        return get_end_time_of_next_minute(timerResolver->timestamp) ;
    } else if (seat == 2) { //小時(shí)數(shù)
        return get_end_time_of_next_hour(timerResolver->timestamp) ;
    } else if (seat == 3) { //天數(shù)
        return get_end_time_of_next_day(timerResolver->timestamp) ;
    } else if (seat == 4) { //星期數(shù)(周末開(kāi)始時(shí)間)
        return get_end_time_of_next_week(timerResolver->timestamp);
    } else if (seat == 5) { //月數(shù)
        return get_end_time_of_next_month(timerResolver->timestamp) ;
    } else if (seat == 6) { //年數(shù)
        return get_end_time_of_next_year(timerResolver->timestamp) ;
    }
}

// 判斷是否有此模式
BOOL mode_exist(char *item, TimerResolver *timerResolver) {
    if(!str_contains(timerResolver->plan,"mode")){
        return FALSE;
    }
    CharHashMapIterator *pIterator = createCharHashMapIterator(timerResolver->mode);
    while (hasNextCharHashMapIterator(pIterator)) {
        CharKvLinkedNode *pNode = nextCharHashMapIterator(pIterator);
        if (str_start_with(item,pNode->key )) {//如果匹配到模式,那么就轉(zhuǎn)換為統(tǒng)一結(jié)構(gòu)化格式
            return TRUE;
        }
    }
    return FALSE;
}

//模式解析
long mode_timer(char *item, int seat, TimerResolver *timerResolver) {
    if (str_contains(timerResolver->plan, "mode")) {
        CharHashMapIterator *pIterator = createCharHashMapIterator(timerResolver->mode);
        while (hasNextCharHashMapIterator(pIterator)) {
            CharKvLinkedNode *pNode = nextCharHashMapIterator(pIterator);
            if (str_start_with(item,pNode->key)) {//如果匹配到模式
                ModeMethod pVoid = (ModeMethod) pNode->value;
                return pVoid(item, seat, timerResolver);//執(zhí)行模式方法
            }
        }
    }
    return 0;// 沒(méi)有匹配到模式
}

//添加模式方法(如果執(zhí)行計(jì)劃為mode,則支持)
void add_timer_mode(TimerResolver *timerResolver, char *key, ModeMethod method) {
    if (str_contains(timerResolver->plan, "mode")) {
        putCharHashMap(timerResolver->mode, key, method);//添加模式方法
    }
}

void inside_add_timer_mode(TimerResolver *timerResolver) {
    if (str_contains(timerResolver->plan, "mode")) {
        add_timer_mode(timerResolver, "begin", time_begin_mode);
        add_timer_mode(timerResolver, "end", time_end_mode);
        add_timer_mode(timerResolver, "point", time_point_mode);
    }
}

//獲取下一次執(zhí)行時(shí)間,返回時(shí)間戳
long get_next_time(TimerResolver *timerResolver) {
    if (!timerResolver->plan) {
        return 0;
    }

    if (str_contains(timerResolver->plan, "mode")) {
        long mode_timer1 = mode_timer(get_return_data(&timerResolver->second), 0, timerResolver);
        timerResolver->timestamp+=get_time_difference_second(timerResolver->timestamp, mode_timer1);
        long mode_timer2 = mode_timer(get_return_data(&timerResolver->minute), 1, timerResolver);
        timerResolver->timestamp+=get_time_difference_second(timerResolver->timestamp,mode_timer2 );
        long mode_timer3= mode_timer(get_return_data(&timerResolver->hour), 2, timerResolver);
        timerResolver->timestamp+=get_time_difference_second(timerResolver->timestamp,mode_timer3 );
        long  mode_timer4 = mode_timer(get_return_data(&timerResolver->day), 3, timerResolver);
        timerResolver->timestamp+=get_time_difference_second(timerResolver->timestamp, mode_timer4);
        long mode_timer5 = mode_timer(get_return_data(&timerResolver->week), 4, timerResolver);
        timerResolver->timestamp+=get_time_difference_second(timerResolver->timestamp, mode_timer5);
        long mode_timer6 = mode_timer(get_return_data(&timerResolver->month), 5, timerResolver);
        timerResolver->timestamp+=get_time_difference_second(timerResolver->timestamp, mode_timer6);
        long mode_timer7 = mode_timer(get_return_data(&timerResolver->year), 6, timerResolver);
        timerResolver->timestamp+=get_time_difference_second(timerResolver->timestamp, mode_timer7);
    }
    long current = timerResolver->timestamp;
    //獲取當(dāng)前時(shí)間
    int second = str_to_int(get_return_data(&timerResolver->second));
    int minute = str_to_int(get_return_data(&timerResolver->minute));
    int hour = str_to_int(get_return_data(&timerResolver->hour));
    int day = str_to_int(get_return_data(&timerResolver->day));
    int week = str_to_int(get_return_data(&timerResolver->week));
    int month = str_to_int(get_return_data(&timerResolver->month));
    int year = str_to_int(get_return_data(&timerResolver->year));
    long newTime = add_time_one(current,
                                second,
                                minute,
                                hour,
                                day,
                                month,
                                year,
                                week
    );
    timerResolver->timestamp = newTime;
    if(str_contains(timerResolver->plan,"mode")){
        return newTime;
    }else{
        return current;
    }
}

//解析字符串-,-,-,-,-,-,-,-并創(chuàng)建TimerResolver
TimerResolver *create_timer_resolver(char *time) {

    if (time == NULL && strlen(time) == 0) {
        return NULL;
    }
    //去空
    time = str_trim(time);
    //排除[]內(nèi)的,號(hào)
    int start = 0;
    while ((start = str_find_n(time, "[", start, str_length(time))) != -1) {
        int end = str_find_n(time, "]", start, str_length(time));
        time = str_replace_all_n(time, ",", "@", start, end);
        start++;
    }

    TimerResolver *timerResolver = (TimerResolver *) malloc(sizeof(TimerResolver));
    if (timerResolver == NULL) {
        return NULL;
    }
    CharList *pCharlist = str_split(time, ",");
    int str_len = pCharlist->len;
    if (str_len != 8) {
        char message[100];
        sprintf(message, "create_timer_resolver語(yǔ)法錯(cuò)誤: %s ", time);
        assertError(message);
    }
    timerResolver->second = pCharlist->str[0];
    timerResolver->minute = pCharlist->str[1];
    timerResolver->hour = pCharlist->str[2];
    timerResolver->day = pCharlist->str[3];
    timerResolver->week = pCharlist->str[4];
    timerResolver->month = pCharlist->str[5];
    timerResolver->year = pCharlist->str[6];
    timerResolver->timestamp = get_current_timestamp();//獲取當(dāng)前時(shí)間戳
    //執(zhí)行計(jì)劃 -代表不執(zhí)行,n 循環(huán)執(zhí)行,數(shù)字代表執(zhí)行次數(shù) , ^n 階級(jí)執(zhí)行(^1 表示一階執(zhí)行,^2 表示二階執(zhí)行,^3 表示三階執(zhí)行...^n表示n階執(zhí)行)
    timerResolver->plan = str_compare(pCharlist->str[7], "-") ? "0" : pCharlist->str[7];
    timerResolver->help = "{}";
    timerResolver->mode = createCharHashMap(10);

    //添加模式方法
    inside_add_timer_mode(timerResolver);

    //轉(zhuǎn)換為結(jié)構(gòu)化格式
    switchStructure(timerResolver);

    //計(jì)算本次執(zhí)行時(shí)間
    if(!str_contains(timerResolver->plan,"mode")){
        get_next_time(timerResolver);
    }

    return timerResolver;
}

//打印TimerResolver,格式為-,-,-,-,-,-,-,-
void print_timer_resolver(TimerResolver *timerResolver) {
    printf("%s,%s,%s,%s,%s,%s,%s,%s\n", timerResolver->second, timerResolver->minute, timerResolver->hour,
           timerResolver->day, timerResolver->week, timerResolver->month, timerResolver->year,
           timerResolver->plan);
}
//執(zhí)行n次定時(shí)器并且打印效果
void print_format_resolver(TimerResolver *timerResolver, int n) {
    for (int i = 0; i < n; ++i){
        long i1 = resolver(timerResolver);
        char *string = format_time(i1, "%Y-%m-%d %H:%M:%S");
        printf("%ld---%s\n",i1,string);
    }
}


//解析定時(shí)器語(yǔ)法,并且生成下次執(zhí)行時(shí)間,如果返回0,則此語(yǔ)法已經(jīng)執(zhí)行結(jié)束了,可以刪除對(duì)應(yīng)的定時(shí)器了
long resolver(TimerResolver *timerResolver) {
    //判斷是否可執(zhí)行
    if (str_equals(timerResolver->plan,"0") ) {//不執(zhí)行
        return 0;
    }

    if (str_compare(timerResolver->plan, "n")) {//循環(huán)執(zhí)行
        return get_next_time(timerResolver);
    }
    //階級(jí)執(zhí)行
    if (str_start_with(timerResolver->plan, "^")) {
        CharHashMap *pMapSecond = str_to_json_map(timerResolver->second);
        putCharHashMap(pMapSecond, "return",
                       int_to_str(str_to_int(get_return_data(&timerResolver->second)) * 2));
        timerResolver->second = map_to_json_str(pMapSecond);

        CharHashMap *pMapMinute = str_to_json_map(timerResolver->minute);
        putCharHashMap(pMapMinute, "return",
                       int_to_str(str_to_int(get_return_data(&timerResolver->minute)) * 2));
        timerResolver->minute = map_to_json_str(pMapMinute);

        CharHashMap *pMapHour = str_to_json_map(timerResolver->hour);
        putCharHashMap(pMapHour, "return",
                       int_to_str(str_to_int(get_return_data(&timerResolver->hour)) * 2));
        timerResolver->hour = map_to_json_str(pMapHour);

        CharHashMap *pMapDay = str_to_json_map(timerResolver->day);
        putCharHashMap(pMapDay, "return",
                       int_to_str(str_to_int(get_return_data(&timerResolver->day)) * 2));
        timerResolver->hour = map_to_json_str(pMapDay);

        CharHashMap *pMapWeek = str_to_json_map(timerResolver->week);
        putCharHashMap(pMapWeek, "return",
                       int_to_str(str_to_int(get_return_data(&timerResolver->week)) * 2));
        timerResolver->week = map_to_json_str(pMapWeek);

        CharHashMap *pMapMonth = str_to_json_map(timerResolver->month);
        putCharHashMap(pMapMonth, "return",
                       int_to_str(str_to_int(get_return_data(&timerResolver->month)) * 2));
        timerResolver->month = map_to_json_str(pMapMonth);

        CharHashMap *pMapYear = str_to_json_map(timerResolver->year);
        putCharHashMap(pMapYear, "return",
                       int_to_str(str_to_int(get_return_data(&timerResolver->year)) * 2));
        timerResolver->year = map_to_json_str(pMapYear);

        char *string = str_substring(timerResolver->plan, 1, str_length(timerResolver->plan));
        if (str_compare(string, "n")) { //如果是n那么就是循環(huán)執(zhí)行
            return get_next_time(timerResolver);
        }
        if (str_is_number(string)) {//如果是數(shù)字,那么就是有限階級(jí)執(zhí)行
            if (str_compare(string, "0")) {
                return 0;
            }
            char *one = str_calculate_one(string, "--");
            timerResolver->plan = str_concat(2, "^", one);
            return get_next_time(timerResolver);
        }
    }
    //模式執(zhí)行
    if (str_start_with(timerResolver->plan, "mode")) {
        timerResolver->timestamp= get_start_time_of_day(timerResolver->timestamp );// 初始化為當(dāng)天的開(kāi)始時(shí)間 ,然后在后面的計(jì)算中,加上指定的時(shí)間
        if (str_length(timerResolver->plan) == 4) { //循環(huán)執(zhí)行
            return get_next_time(timerResolver);
        } else {
            char *string = str_substring(timerResolver->plan, 4, str_length(timerResolver->plan));
            if (str_is_number(string)) {//如果是數(shù)字,那么就是有限階級(jí)執(zhí)行
                if (str_compare(string, "0")) {
                    return 0;
                }
                char *one = str_calculate_one(string, "--");
                timerResolver->plan = str_concat(2, "mode", one);
                return get_next_time(timerResolver);
            } else {
                assertError(formatStr("mode解析錯(cuò)誤非法字符(必須是mode+數(shù)字):%s\n", timerResolver->plan));
            }
        }
    }
    //有限執(zhí)行
    if (str_is_number(timerResolver->plan)) {
        int plan = str_to_int(timerResolver->plan);
        if (plan > 0) {
            timerResolver->plan = int_to_str(plan - 1);
            return get_next_time(timerResolver);
        }

    }

}


//分段[]解析
char *section_analysis(char *item, TimerResolver *timerResolver) {
    //在幫助里存儲(chǔ)當(dāng)前的次數(shù)
    CharHashMap *pMap = str_to_json_map(timerResolver->help);
    if (!containsKeyCharHashMap(pMap, "basicsPlan")) {
        putCharHashMap(pMap, "basicsPlan", timerResolver->plan);
        timerResolver->help = map_to_json_str(pMap);
    }
    //將[]里面的@轉(zhuǎn)換為,號(hào)
    item = str_replace_all_n(item, "@", ",", 0, str_length(item));
    CharList *pCharlist = str_to_json_array(item);
    //驗(yàn)證是否都是數(shù)字
    for (int i = 0; i < pCharlist->len; ++i) {
        if (!str_is_number(pCharlist->str[i])) {
            assertError(formatStr("[]解析錯(cuò)誤非法字符(必須是數(shù)字):%s\n", pCharlist->str[i]));
        }
    }
    char *string = str_concat(11, "{", "type:[]", ",", "data:", item, ",", "index:0", ",", "return:",
                              pCharlist->str[0], "}");
    //添加執(zhí)行的次數(shù)
    CharHashMap *pMap1 = str_to_json_map(timerResolver->help);
    char *basicsPlan = getCharHashMap(pMap1, "basicsPlan");
    if(str_equals(basicsPlan,"n")||str_start_with(basicsPlan,"^")){
        timerResolver->plan = timerResolver->plan;
    }else{
        if (str_equals(timerResolver->plan, basicsPlan)) {
            timerResolver->plan = int_to_str(pCharlist->len * str_to_int(basicsPlan));
        } else {
            timerResolver->plan = int_to_str(
                    str_to_int(timerResolver->plan) + (pCharlist->len * str_to_int(basicsPlan)));
        }
    }
    return string;
}

//區(qū)間解析 符號(hào)為~ ,位置1表示秒,2表示分支,3表示小時(shí),4表示天,5表示星期,6表示月,7表示年
char *range_analysis(char *item, TimerResolver *timerResolver) {
    //在幫助里存儲(chǔ)當(dāng)前的次數(shù)
    CharHashMap *pMap = str_to_json_map(timerResolver->help);
    if (!containsKeyCharHashMap(pMap, "basicsPlan")) {
        putCharHashMap(pMap, "basicsPlan", timerResolver->plan);
        timerResolver->help = map_to_json_str(pMap);
    }

    CharList *pCharlist = str_split(item, "~");
    //驗(yàn)證是否都是數(shù)字
    for (int i = 0; i < pCharlist->len; ++i) {
        if (!str_is_number(pCharlist->str[i])) {
            assertError(formatStr("~解析錯(cuò)誤非法字符(必須是數(shù)字):%s\n", pCharlist->str[i]));
        }
    }
    CharList *range = get_range(pCharlist->str[0], pCharlist->str[1]);
    char *data = array_to_json_str(range);
    char *string = str_concat(11, "{", "type:~", ",", "data:", data, ",", "index:0", ",", "return:", range->str[0],
                              "}");
    //添加執(zhí)行的次數(shù)
    CharHashMap *pMap1 = str_to_json_map(timerResolver->help);
    char *basicsPlan = getCharHashMap(pMap1, "basicsPlan");
    if(str_equals(basicsPlan,"n")||str_start_with(basicsPlan,"^")){
        timerResolver->plan = timerResolver->plan;
    }else{
        if (str_equals(timerResolver->plan, basicsPlan)) {
            timerResolver->plan = int_to_str(range->len * str_to_int(basicsPlan));
        } else {
            timerResolver->plan = int_to_str(str_to_int(timerResolver->plan) + (range->len * str_to_int(basicsPlan)));
        }
    }

    return string;
}


//間隔/ 解析  (5/2)表示從5開(kāi)始,每隔2個(gè)數(shù) 執(zhí)行一次
char *interval_analysis(char *item, TimerResolver *timerResolver) {
    //在幫助里存儲(chǔ)當(dāng)前的次數(shù)
    CharHashMap *pMap = str_to_json_map(timerResolver->help);
    if (!containsKeyCharHashMap(pMap, "basicsPlan")) {
        putCharHashMap(pMap, "basicsPlan", timerResolver->plan);
        timerResolver->help = map_to_json_str(pMap);
    }

    CharList *pCharlist = str_split(item, "/");
    //驗(yàn)證是否都是數(shù)字
    for (int i = 0; i < pCharlist->len; ++i) {
        if (!str_is_number(pCharlist->str[i])) {
            assertError(formatStr("/解析錯(cuò)誤非法字符(必須是數(shù)字):%s\n", pCharlist->str[i]));
        }
    }
    char *data = str_concat(5, "[", pCharlist->str[0], ",", pCharlist->str[1], "]");
    char *string = str_concat(11, "{", "type:/", ",", "data:", data, ",", "index:0", ",", "return:", pCharlist->str[0],
                              "}");
    //添加執(zhí)行的次數(shù)
    CharHashMap *pMap1 = str_to_json_map(timerResolver->help);
    char *basicsPlan = getCharHashMap(pMap1, "basicsPlan");
    if(str_equals(basicsPlan,"n")||str_start_with(basicsPlan,"^")){
        timerResolver->plan = timerResolver->plan;
    }else{
        if (str_equals(timerResolver->plan, basicsPlan)) {
            timerResolver->plan = int_to_str(str_to_int(basicsPlan) + 1);
        }
    }
    return string;
}

char *mode_analysis(char *item, TimerResolver *timerResolver) {
    CharHashMapIterator *pIterator = createCharHashMapIterator(timerResolver->mode);
    while (hasNextCharHashMapIterator(pIterator)) {
        CharKvLinkedNode *pNode = nextCharHashMapIterator(pIterator);
        if (str_start_with(item,pNode->key)) {//如果匹配到模式,那么就轉(zhuǎn)換為統(tǒng)一結(jié)構(gòu)化格式
            char *string = str_concat(6, "{", "type:mode", ",", "return:", item, "}");
            return string;
        }
    }
    assertError(formatStr("mode模式解析錯(cuò)誤沒(méi)有找到對(duì)應(yīng)的模式-請(qǐng)檢查模式是否自定義-并且添加到模式集中:%s\n", item));
}


//普通解析
char *normal_analysis(char *item) {
    if (str_is_number(item)) {
        char *string = str_concat(6, "{", "type:number", ",", "return:", item, "}");
        return string;
    }
    assertError(formatStr("解析錯(cuò)誤,無(wú)法解析的表達(dá)式:%s\n", item));
}


//獲取結(jié)構(gòu)化數(shù)據(jù)的返回?cái)?shù)據(jù)
char *get_return_data(char **data1) {

    char *data = *data1;
    //判斷是否是字典格式
    if (str_is_map(data)) {
        //解析字典
        CharHashMap *pMap = str_to_json_map(data);
        //獲取類(lèi)型
        char *type = getCharHashMap(pMap, "type");
        //如果類(lèi)型是[]
        if (str_compare(type,
                        "[]")) { //如果是[]類(lèi)型 那么就是分段  例如 [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24]
            //獲取data
            char *data = getCharHashMap(pMap, "data");
            //獲取index
            char *index = getCharHashMap(pMap, "index");
            //獲取返回?cái)?shù)據(jù)
            char *returnData = getCharHashMap(pMap, "return");
            //獲取數(shù)組
            //將[]里面的@轉(zhuǎn)換為,號(hào)
            CharList *pCharlist = str_to_json_array(data);
            //獲取下一個(gè)值
            int nextIndex = str_to_int(index) + 1;
            //判斷是否超出數(shù)組長(zhǎng)度,如果超出長(zhǎng)度,從頭開(kāi)始
            if (nextIndex >= pCharlist->len) {
                //超出長(zhǎng)度,返回空
                nextIndex = 0;
            }
            //獲取下一個(gè)值
            char *nextValue = pCharlist->str[nextIndex];
            //設(shè)置返回?cái)?shù)據(jù)
            putCharHashMap(pMap, "return", nextValue);
            //設(shè)置index
            putCharHashMap(pMap, "index", int_to_str(nextIndex));
            //修改原數(shù)據(jù)
            *data1 = map_to_json_str(pMap);
            //返回?cái)?shù)據(jù)
            return returnData;
        } else if (str_compare(type, "~")) { //如果類(lèi)型是~ 那么就是區(qū)間 1~5 表示1,2,3,4,5
            //如果類(lèi)型是~
            //獲取data
            char *data = getCharHashMap(pMap, "data");
            //獲取index
            char *index = getCharHashMap(pMap, "index");
            //獲取返回?cái)?shù)據(jù)
            char *returnData = getCharHashMap(pMap, "return");
            //獲取數(shù)組
            CharList *pCharlist = str_to_json_array(data);
            //獲取下一個(gè)值
            int nextIndex = str_to_int(index) + 1;
            //判斷是否超出數(shù)組長(zhǎng)度,如果超出長(zhǎng)度,從頭開(kāi)始
            if (nextIndex >= pCharlist->len) {
                nextIndex = 0;
            }
            //獲取下一個(gè)值
            char *nextValue = pCharlist->str[nextIndex];
            //設(shè)置返回?cái)?shù)據(jù)
            putCharHashMap(pMap, "return", nextValue);
            //設(shè)置index
            putCharHashMap(pMap, "index", int_to_str(nextIndex));
            //修改原數(shù)據(jù)
            *data1 = map_to_json_str(pMap);
            //返回?cái)?shù)據(jù)
            return returnData;

        } else if (str_compare(type, "/")) { // 如果類(lèi)型是/ (5/2)表示從5開(kāi)始,每隔2個(gè)數(shù) 執(zhí)行一次
            //如果類(lèi)型是/
            //獲取data
            char *data = getCharHashMap(pMap, "data");
            //獲取index
            char *index = getCharHashMap(pMap, "index");
            //獲取返回?cái)?shù)據(jù)
            char *returnData = getCharHashMap(pMap, "return");
            int nextIndex = str_to_int(index) + 1;
            if (nextIndex == 1) {
                //獲取數(shù)組
                CharList *pCharlist = str_to_json_array(data);
                //判斷index是否是1,如果是1,取第二個(gè)值,并且轉(zhuǎn)換為普通結(jié)構(gòu)
                char *string = str_concat(6, "{", "type:number", ",", "return:", pCharlist->str[nextIndex], "}");
                *data1 = string;
            }
            return returnData;
        } else if (str_compare(type, "number")) {
            //如果類(lèi)型是number,那么獲取return
            char *returnData = getCharHashMap(pMap, "return");
            return returnData;
        }else if (str_compare(type, "mode")) {
            //如果類(lèi)型是mode,那么獲取return
            char *returnData = getCharHashMap(pMap, "return");
            return returnData;
        }
    }
    assertError(formatStr("解析錯(cuò)誤不是結(jié)構(gòu)化數(shù)據(jù): %s\n", data));

}

//定時(shí)器語(yǔ)法轉(zhuǎn)換為結(jié)構(gòu)化格式
void switchStructure(TimerResolver *timerResolver) {
    //秒
    if (str_contains(timerResolver->second, "[")) {
        timerResolver->second = section_analysis(timerResolver->second, timerResolver);
    } else if (str_contains(timerResolver->second, "~")) {
        timerResolver->second = range_analysis(timerResolver->second, timerResolver);
    } else if (str_contains(timerResolver->second, "/")) {
        timerResolver->second = interval_analysis(timerResolver->second, timerResolver);
    } else if (mode_exist(timerResolver->second, timerResolver)) {
        timerResolver->second = mode_analysis(timerResolver->second, timerResolver);
    } else {
        timerResolver->second = normal_analysis(timerResolver->second);
    }
    //分
    if (str_contains(timerResolver->minute, "[")) {
        timerResolver->minute = section_analysis(timerResolver->minute, timerResolver);
    } else if (str_contains(timerResolver->minute, "~")) {
        timerResolver->minute = range_analysis(timerResolver->minute, timerResolver);
    } else if (str_contains(timerResolver->minute, "/")) {
        timerResolver->minute = interval_analysis(timerResolver->minute, timerResolver);
    } else if (mode_exist(timerResolver->minute, timerResolver)) {
        timerResolver->minute = mode_analysis(timerResolver->minute, timerResolver);
    } else {
        timerResolver->minute = normal_analysis(timerResolver->minute);
    }
    //時(shí)
    if (str_contains(timerResolver->hour, "[")) {
        timerResolver->hour = section_analysis(timerResolver->hour, timerResolver);
    } else if (str_contains(timerResolver->hour, "~")) {
        timerResolver->hour = range_analysis(timerResolver->hour, timerResolver);
    } else if (str_contains(timerResolver->hour, "/")) {
        timerResolver->hour = interval_analysis(timerResolver->hour, timerResolver);
    } else if (mode_exist(timerResolver->hour, timerResolver)) {
        timerResolver->hour = mode_analysis(timerResolver->hour, timerResolver);
    } else {
        timerResolver->hour = normal_analysis(timerResolver->hour);
    }
    //日
    if (str_contains(timerResolver->day, "[")) {
        timerResolver->day = section_analysis(timerResolver->day, timerResolver);
    } else if (str_contains(timerResolver->day, "~")) {
        timerResolver->day = range_analysis(timerResolver->day, timerResolver);
    } else if (str_contains(timerResolver->day, "/")) {
        timerResolver->day = interval_analysis(timerResolver->day, timerResolver);
    } else if (mode_exist(timerResolver->day, timerResolver)) {
        timerResolver->day = mode_analysis(timerResolver->day, timerResolver);
    } else {
        timerResolver->day = normal_analysis(timerResolver->day);
    }
    //周
    if (str_contains(timerResolver->week, "[")) {
        timerResolver->week = section_analysis(timerResolver->week, timerResolver);
    } else if (str_contains(timerResolver->week, "~")) {
        timerResolver->week = range_analysis(timerResolver->week, timerResolver);
    } else if (str_contains(timerResolver->week, "/")) {
        timerResolver->week = interval_analysis(timerResolver->week, timerResolver);
    } else if (mode_exist(timerResolver->week, timerResolver)) {
        timerResolver->week = mode_analysis(timerResolver->week, timerResolver);
    } else {
        timerResolver->week = normal_analysis(timerResolver->week);
    }
    //月
    if (str_contains(timerResolver->month, "[")) {
        timerResolver->month = section_analysis(timerResolver->month, timerResolver);
    } else if (str_contains(timerResolver->month, "~")) {
        timerResolver->month = range_analysis(timerResolver->month, timerResolver);
    } else if (str_contains(timerResolver->month, "/")) {
        timerResolver->month = interval_analysis(timerResolver->month, timerResolver);
    } else if (mode_exist(timerResolver->month, timerResolver)) {
        timerResolver->month = mode_analysis(timerResolver->month, timerResolver);
    } else {
        timerResolver->month = normal_analysis(timerResolver->month);
    }
    //年
    if (str_contains(timerResolver->year, "[")) {
        timerResolver->year = section_analysis(timerResolver->year, timerResolver);
    } else if (str_contains(timerResolver->year, "~")) {
        timerResolver->year = range_analysis(timerResolver->year, timerResolver);
    } else if (str_contains(timerResolver->year, "/")) {
        timerResolver->year = interval_analysis(timerResolver->year, timerResolver);
    } else if (mode_exist(timerResolver->year, timerResolver)) {
        timerResolver->year = mode_analysis(timerResolver->year, timerResolver);
    } else {
        timerResolver->year = normal_analysis(timerResolver->year);
    }

}

//釋放TimerResolver
void free_timer_resolver(TimerResolver *timerResolver) {
    free(timerResolver);
}