package clog

import (
	"context"
	"fmt"
	"google.golang.org/grpc/metadata"
	"log"
	"runtime"
)

const (
	LOG_DEBUG = 0
	LOG_INFO  = 1
	LOG_WARN  = 2
	LOG_ERROR = 3
	LOG_FATAL = 4
)

const (
	debug_str = "\033[0;32m[DEBUG]\033[0;0m"
	info_str  = "\033[0m[INFO]\033[0;0m"
	warn_str  = "\033[1;33m[WARN]\033[0;0m"
	error_str = "\033[0;31m[ERROR]\033[0;0m"
	fatal_str = "\033[0;31m[FATAL]\033[0;0m"
)

const (
	Llongfile         = 1 << iota // log调用者路径
	Lshortfile                    // log调用者文件名
	Lfuncname                     // 调用函数名
	LerrorExit                    // error log关闭程序
	Lfilemask         = Llongfile | Lshortfile | Lfuncname
	default_calldepth = 3 // 函数调用深度
)

// debug模块定义
const (
	LDM_NONE  = 0
	LDM_ALL   = 1
	LDM_QUEST = 2
	LDM_LOGIN = 3
)

var (
	_log_level = LOG_INFO
	_log_flag  = Lshortfile | Lfuncname // | LerrorExit
)

func logPrefix(calldepth int) (ret string) {
	if (_log_flag & Lfilemask) != 0 {
		var ok bool
		var funcName string
		pc, file, line, ok := runtime.Caller(calldepth)
		if !ok {
			file = "???"
			line = 0
		}
		if (_log_flag & Llongfile) != 0 {
			ret += file + fmt.Sprintf(":%d ", line)
		} else if (_log_flag & Lshortfile) != 0 {
			for i := len(file) - 1; i > 0; i-- {
				if file[i] == '/' {
					file = file[i+1:]
					break
				}
			}
			ret += file + fmt.Sprintf(":%d ", line)
		}
		if (_log_flag & Lfuncname) != 0 {
			fc := runtime.FuncForPC(pc)
			if fc != nil {
				funcName = fc.Name() + "()"
			} else {
				funcName = "?()"
			}
			ret += funcName
		}
	}
	return
}

func LogDebug(ctx context.Context, v ...interface{}) {
	if _log_level > LOG_DEBUG {
		return
	}
	str := formatLog(ctx, LOG_DEBUG, default_calldepth, v...)
	log.Println(str)
}

func LogDebugc(ctx context.Context, calldepth int, v ...interface{}) {
	if _log_level > LOG_DEBUG {
		return
	}
	str := formatLog(ctx, LOG_DEBUG, calldepth, v...)
	log.Println(str)
}

func LogDebugf(ctx context.Context, format string, v ...interface{}) {
	if _log_level > LOG_DEBUG {
		return
	}
	str := formatLogf(ctx, LOG_DEBUG, default_calldepth, format, v...)
	log.Println(str)
}

func LogInfo(ctx context.Context, v ...interface{}) {
	if _log_level > LOG_INFO {
		return
	}
	str := formatLog(ctx, LOG_INFO, default_calldepth, v...)
	log.Println(str)
}

func LogInfoc(ctx context.Context, calldepth int, v ...interface{}) {
	if _log_level > LOG_INFO {
		return
	}
	str := formatLog(ctx, LOG_INFO, calldepth, v...)
	log.Println(str)
}

func LogInfof(ctx context.Context, format string, v ...interface{}) {
	if _log_level > LOG_INFO {
		return
	}
	str := formatLogf(ctx, LOG_INFO, default_calldepth, format, v...)
	log.Println(str)
}

func LogWarn(ctx context.Context, v ...interface{}) {
	if _log_level > LOG_WARN {
		return
	}
	str := formatLog(ctx, LOG_WARN, default_calldepth, v...)
	log.Println(str)
}

func LogWarnc(ctx context.Context, calldepth int, v ...interface{}) {
	if _log_level > LOG_WARN {
		return
	}
	str := formatLog(ctx, LOG_WARN, calldepth, v...)
	log.Println(str)
}

func LogWarnf(ctx context.Context, format string, v ...interface{}) {
	if _log_level > LOG_WARN {
		return
	}
	str := formatLogf(ctx, LOG_WARN, default_calldepth, format, v...)
	log.Println(str)
}

func LogErr(ctx context.Context, v ...interface{}) {
	if _log_level > LOG_ERROR {
		return
	}
	str := formatLog(ctx, LOG_ERROR, default_calldepth, v...)
	if logger := GetLogger("error"); logger != nil {
		logger.Println(str)
	}
	if (_log_flag & LerrorExit) != 0 {
		log.Fatalln(str)
	} else {
		log.Println(str)
	}
}

func LogErrc(ctx context.Context, calldepth int, v ...interface{}) {
	if _log_level > LOG_ERROR {
		return
	}
	str := formatLog(ctx, LOG_ERROR, calldepth, v...)
	if logger := GetLogger("error"); logger != nil {
		logger.Println(str)
	}

	if (_log_flag & LerrorExit) != 0 {
		log.Fatalln(str)
	} else {
		log.Println(str)
	}
}

func LogErrf(ctx context.Context, format string, v ...interface{}) {
	if _log_level > LOG_ERROR {
		return
	}
	str := formatLogf(ctx, LOG_ERROR, default_calldepth, format, v...)
	if logger := GetLogger("error"); logger != nil {
		logger.Println(str)
	}

	if (_log_flag & LerrorExit) != 0 {
		log.Fatalln(str)
	} else {
		log.Println(str)
	}
}

func LogFatal(ctx context.Context, v ...interface{}) {
	str := formatLog(ctx, LOG_FATAL, default_calldepth, v...)
	log.Println(str)
	if logger := GetLogger("error"); logger != nil {
		logger.Fatal(str)
	}
}

func LogFatalc(ctx context.Context, calldepth int, v ...interface{}) {
	str := formatLog(ctx, LOG_FATAL, calldepth, v...)
	log.Println(str)
	if logger := GetLogger("error"); logger != nil {
		logger.Fatal(str)
	}
}

func LogFatalf(ctx context.Context, format string, v ...interface{}) {
	str := formatLogf(ctx, LOG_FATAL, default_calldepth, format, v...)
	log.Println(str)
	if logger := GetLogger("error"); logger != nil {
		logger.Fatal(str)
	}
}

func formatLog(ctx context.Context, level int, calldepth int, v ...interface{}) string {
	var pre_str string
	var post_str string

	switch level {
	case LOG_DEBUG:
		pre_str = debug_str
	case LOG_INFO:
		pre_str = info_str
	case LOG_WARN:
		pre_str = warn_str
	case LOG_ERROR:
		pre_str = error_str
	case LOG_FATAL:
		pre_str = fatal_str
	}

	requestId := getRequestId(ctx)
	if len(requestId) > 0 {
		post_str += fmt.Sprintf("%s requestId:%s,%s %s", pre_str, getRequestId(ctx), fmt.Sprint(v...), " ["+logPrefix(calldepth)+"]")
	} else {
		post_str += fmt.Sprintf("%s %s %s", pre_str, fmt.Sprint(v...), " ["+logPrefix(calldepth)+"]")
	}

	return post_str
}

func formatLogf(ctx context.Context, level int, calldepth int, format string, v ...interface{}) string {
	var pre_str string
	var post_str string
	switch level {
	case LOG_DEBUG:
		pre_str = debug_str
	case LOG_INFO:
		pre_str = info_str
	case LOG_WARN:
		pre_str = warn_str
	case LOG_ERROR:
		pre_str = error_str
	case LOG_FATAL:
		pre_str = fatal_str
	}

	requestId := getRequestId(ctx)
	if len(requestId) > 0 {
		post_str += fmt.Sprintf("%s requestId:%s,%s %s", pre_str, requestId, fmt.Sprintf(format, v...), " ["+logPrefix(calldepth)+"]")
	} else {
		post_str += fmt.Sprintf("%s %s %s", pre_str, fmt.Sprintf(format, v...), " ["+logPrefix(calldepth)+"]")
	}
	return post_str
}

func getRequestId(ctx context.Context) string {
	md2, ok := metadata.FromIncomingContext(ctx)
	if !ok {
		return ""
	}
	if len(md2["requestid"]) >= 1 {
		return md2["requestid"][0]
	}
	return ""
}