// Copyright(c) 2021. Huawei Technologies Co.,Ltd. All rights reserved.

// Package hwlog provides the capability of processing Huawei log rules.
package hwlog

import (
"context"
"fmt"
"go.uber.org/zap"
)

// Logger logger struct
type Logger struct {
ZapLogger *zap.Logger
}

// NewLogger create Logger
func NewLogger() *Logger {
newLogger := new(Logger)
return newLogger
}

// InitLogger initialize run logger
func (lg *Logger) InitLogger(config *LogConfig, stopCh <-chan struct{}) error {
if lg != nil && lg.ZapLogger != nil {
lg.Warn("logger is been initialized.")
return nil
}
zapLog, err := Init(config, stopCh)
if err != nil {
return err
}
lg.ZapLogger = zapLog
return nil
}

// IsInit check logger initialized
func (lg *Logger) IsInit() bool {
return lg.ZapLogger != nil
}

// Debug record debug not format
func (lg *Logger) Debug(args …interface{}) {
lg.DebugWithCtx(nil, args…)
}

// Debugf record debug
func (lg *Logger) Debugf(format string, args …interface{}) {
lg.DebugfWithCtx(nil, format, args…)
}

// DebugWithCtx record Debug not format
func (lg *Logger) DebugWithCtx(ctx context.Context, args …interface{}) {
if lg.validate() {
printHelper(lg.ZapLogger.Debug, fmt.Sprint(args…), ctx)
}
}

// DebugfWithCtx record Debug format
func (lg *Logger) DebugfWithCtx(ctx context.Context, format string, args …interface{}) {
if lg.validate() {
printHelper(lg.ZapLogger.Debug, fmt.Sprintf(format, args…), ctx)
}
}

// Info record info not format
func (lg *Logger) Info(args …interface{}) {
lg.InfoWithCtx(nil, args…)
}

// Infof record info
func (lg *Logger) Infof(format string, args …interface{}) {
lg.InfofWithCtx(nil, format, args…)
}

// InfoWithCtx record Info not format with context, if you have no ctx, please use the method with not ctx
func (lg *Logger) InfoWithCtx(ctx context.Context, args …interface{}) {
if lg.validate() {
printHelper(lg.ZapLogger.Info, fmt.Sprint(args…), ctx)
}
}

// InfofWithCtx record Info format with context, if you have no ctx, please use the method with not ctx
func (lg *Logger) InfofWithCtx(ctx context.Context, format string, args …interface{}) {
if lg.validate() {
printHelper(lg.ZapLogger.Info, fmt.Sprintf(format, args…), ctx)
}
}

// Warn record warn not format
func (lg *Logger) Warn(args …interface{}) {
lg.WarnWithCtx(nil, args…)
}

// Warnf record warn
func (lg *Logger) Warnf(format string, args …interface{}) {
lg.WarnfWithCtx(nil, format, args…)
}

// WarnWithCtx record Warn not format with context, if you have no ctx, please use the method with not ctx
func (lg *Logger) WarnWithCtx(ctx context.Context, args …interface{}) {
if lg.validate() {
printHelper(lg.ZapLogger.Warn, fmt.Sprint(args…), ctx)
}
}

// WarnfWithCtx record Warn format with context, if you have no ctx, please use the method with not ctx
func (lg *Logger) WarnfWithCtx(ctx context.Context, format string, args …interface{}) {
if lg.validate() {
printHelper(lg.ZapLogger.Warn, fmt.Sprintf(format, args…), ctx)
}
}

// Error record error not format
func (lg *Logger) Error(args …interface{}) {
lg.ErrorWithCtx(nil, args…)
}

// Errorf record error
func (lg *Logger) Errorf(format string, args …interface{}) {
lg.ErrorfWithCtx(nil, format, args…)
}

// ErrorWithCtx record Error not format with context, if you have no ctx, please use the method with not ctx
func (lg *Logger) ErrorWithCtx(ctx context.Context, args …interface{}) {
if lg.validate() {
printHelper(lg.ZapLogger.Error, fmt.Sprint(args…), ctx)
}
}

// ErrorfWithCtx record Error format with context, if you have no ctx, please use the method with not ctx
func (lg *Logger) ErrorfWithCtx(ctx context.Context, format string, args …interface{}) {
if lg.validate() {
printHelper(lg.ZapLogger.Error, fmt.Sprintf(format, args…), ctx)
}
}

// Dpanic record DPanic not format
func (lg *Logger) Dpanic(args …interface{}) {
lg.DPanicWithCtx(nil, args…)
}

// Dpanicf record DPanic
func (lg *Logger) Dpanicf(format string, args …interface{}) {
lg.DPanicfWithCtx(nil, format, args…)
}

// DPanicWithCtx record DPanic not format with context, if you have no ctx, please use the method with not ctx
func (lg *Logger) DPanicWithCtx(ctx context.Context, args …interface{}) {
if lg.validate() {
printHelper(lg.ZapLogger.DPanic, fmt.Sprint(args…), ctx)
}
}

// DPanicfWithCtx record DPanic format with context, if you have no ctx, please use the method with not ctx
func (lg *Logger) DPanicfWithCtx(ctx context.Context, format string, args …interface{}) {
if lg.validate() {
printHelper(lg.ZapLogger.DPanic, fmt.Sprintf(format, args…), ctx)
}
}

// Panic record panic not format with context, if you have no ctx, please use the method with not ctx
func (lg *Logger) Panic(args …interface{}) {
lg.PanicWithCtx(nil, args…)
}

// Panicf record panic
func (lg *Logger) Panicf(format string, args …interface{}) {
lg.PanicfWithCtx(nil, format, args…)
}

// PanicWithCtx record panic not format with context, if you have no ctx, please use the method with not ctx
func (lg *Logger) PanicWithCtx(ctx context.Context, args …interface{}) {
if lg.validate() {
printHelper(lg.ZapLogger.Panic, fmt.Sprint(args…), ctx)
}
}

// PanicfWithCtx record panic format with context, if you have no ctx, please use the method with not ctx
func (lg *Logger) PanicfWithCtx(ctx context.Context, format string, args …interface{}) {
if lg.validate() {
printHelper(lg.ZapLogger.Panic, fmt.Sprintf(format, args…), ctx)
}
}

// Fatal record fatal not format
func (lg *Logger) Fatal(args …interface{}) {
lg.FatalWithCtx(nil, args…)
}

// Fatalf record fatal
func (lg *Logger) Fatalf(format string, args …interface{}) {
lg.FatalfWithCtx(nil, format, args…)
}

// FatalWithCtx record fatal not format with context, if you have no ctx, please use the method with not ctx
func (lg *Logger) FatalWithCtx(ctx context.Context, args …interface{}) {
if lg.validate() {
printHelper(lg.ZapLogger.Fatal, fmt.Sprint(args…), ctx)
}
}

// FatalfWithCtx record fatal format with context, if you have no ctx, please use the method with not ctx
func (lg *Logger) FatalfWithCtx(ctx context.Context, format string, args …interface{}) {
if lg.validate() {
printHelper(lg.ZapLogger.Fatal, fmt.Sprintf(format, args…), ctx)
}
}

func (lg *Logger) validate() bool {
if lg.ZapLogger == nil {
fmt.Println("Fatal function's logger is nil")
return false
}
return true
}