package logparse

import (
	"encoding/json"
	"fmt"
	"strings"
	"unicode/utf8"
)

type filebeat struct {
	Message string `json:"message"`
}

type Log struct {
	Time    string
	Title   string
	Message string
	Level   string
	App     string
}

var lineSplitChar = "\n"
var leftMiddleBracketsChar = "["
var rightMiddleBracketsChar = "]"
var assemblyChars = "Assembly"
var titleChars = "Title"
var messageChars = "Message :"
var sysLogStartChars1 = "at lambda_method(Closure , Object )"
var sysLogStartChars2 = "at Microsoft.Extensions."
var sysLogStartChars3 = "at Microsoft.AspNetCore"

func LogParseStart(parse <-chan *string, db chan<- *Log) {

	for fileBeatStr := range parse {

		jsonobj := filebeat{}

		err := json.Unmarshal([]byte(*fileBeatStr), &jsonobj)

		if err != nil {
			println(err)
		}

		log, err := parseLog(&jsonobj.Message)

		if err != nil {
			fmt.Println(err)
		} else {
			db <- log
		}

	}
}

func parseLog(logChars *string) (log *Log, err error) {

	defer func() {
		if p := recover(); p != nil {
			err = fmt.Errorf("解析日志失败:%v", p)
		}
	}()

	log = &Log{}

	lines := strings.Split(*logChars, lineSplitChar)

	for index, line := range lines {

		i := index + 1

		if i == 1 && strings.HasPrefix(line, leftMiddleBracketsChar) {

			timeEndIndex := strings.Index(line, rightMiddleBracketsChar)

			log.Level = slice(line, timeEndIndex+2, -1)
			log.Time = slice(line, strings.Index(line, leftMiddleBracketsChar)+1, timeEndIndex-1)
		}

		if i == 2 && strings.HasPrefix(line, assemblyChars) {

			log.App = strings.TrimSpace(slice(line, 9, -1))
		}

		if i == 3 && strings.HasPrefix(line, titleChars) {
			log.Title = slice(line, 7, -1)
		}

		if i > 3 {

			if utf8Len(line) > 0 {

				if i == 4 && strings.HasPrefix(line, messageChars) {
					line = slice(line, 9, -1)
				}

				if log.Level == "ERROR" &&
					(strings.HasPrefix(strings.TrimSpace(line), sysLogStartChars1) ||
						strings.HasPrefix(strings.TrimSpace(line), sysLogStartChars2) ||
						strings.HasPrefix(strings.TrimSpace(line), sysLogStartChars3)) {

					continue
				}
			}

			log.Message += line + "\n"
		}

	}

	return
}

func slice(str string, start int, end int) string {

	str2 := []rune(str)

	len := len(str2)

	if start < 0 || start > len {
		start = 0
	}
	if end < 0 || end > len {
		end = len
	}

	return string(str2[start:end])
}

func utf8Len(str string) int {
	return utf8.RuneCountInString(str)
}