package benchmark

import (
	"bytes"
	"encoding/json"
	"testing"

	gojay "github.com/francoispqt/gojay"
	gojson "github.com/goccy/go-json"
	jsoniter "github.com/json-iterator/go"
	segmentiojson "github.com/segmentio/encoding/json"
)

func Benchmark_Decode_SmallStruct_Unmarshal_EncodingJson(b *testing.B) {
	b.ReportAllocs()
	for n := 0; n < b.N; n++ {
		result := SmallPayload{}
		if err := json.Unmarshal(SmallFixture, &result); err != nil {
			b.Fatal(err)
		}
	}
}

func Benchmark_Decode_SmallStruct_Unmarshal_JsonIter(b *testing.B) {
	b.ReportAllocs()
	for n := 0; n < b.N; n++ {
		result := SmallPayload{}
		if err := jsoniter.Unmarshal(SmallFixture, &result); err != nil {
			b.Fatal(err)
		}
	}
}

func Benchmark_Decode_SmallStruct_Unmarshal_EasyJson(b *testing.B) {
	b.ReportAllocs()
	for i := 0; i < b.N; i++ {
		result := NewSmallPayloadEasyJson()
		if err := result.UnmarshalJSON(SmallFixture); err != nil {
			b.Fatal(err)
		}
	}
}

func Benchmark_Decode_SmallStruct_Unmarshal_GoJay(b *testing.B) {
	b.ReportAllocs()
	for n := 0; n < b.N; n++ {
		result := SmallPayload{}
		if err := gojay.UnmarshalJSONObject(SmallFixture, &result); err != nil {
			b.Fatal(err)
		}
	}
}

func Benchmark_Decode_SmallStruct_Unmarshal_GoJayUnsafe(b *testing.B) {
	b.ReportAllocs()
	for i := 0; i < b.N; i++ {
		result := SmallPayload{}
		if err := gojay.Unsafe.UnmarshalJSONObject(SmallFixture, &result); err != nil {
			b.Fatal(err)
		}
	}
}

func Benchmark_Decode_SmallStruct_Unmarshal_SegmentioJson(b *testing.B) {
	b.ReportAllocs()
	for n := 0; n < b.N; n++ {
		result := SmallPayload{}
		if err := segmentiojson.Unmarshal(SmallFixture, &result); err != nil {
			b.Fatal(err)
		}
	}
}

func Benchmark_Decode_SmallStruct_Unmarshal_GoJson(b *testing.B) {
	b.ReportAllocs()
	for i := 0; i < b.N; i++ {
		result := SmallPayload{}
		if err := gojson.Unmarshal(SmallFixture, &result); err != nil {
			b.Fatal(err)
		}
	}
}

func Benchmark_Decode_SmallStruct_Unmarshal_GoJsonNoEscape(b *testing.B) {
	b.ReportAllocs()
	for i := 0; i < b.N; i++ {
		result := SmallPayload{}
		if err := gojson.UnmarshalNoEscape(SmallFixture, &result); err != nil {
			b.Fatal(err)
		}
	}
}

func Benchmark_Decode_SmallStruct_Stream_EncodingJson(b *testing.B) {
	b.ReportAllocs()
	reader := bytes.NewReader(SmallFixture)
	for i := 0; i < b.N; i++ {
		result := SmallPayload{}
		reader.Reset(SmallFixture)
		if err := json.NewDecoder(reader).Decode(&result); err != nil {
			b.Fatal(err)
		}
	}
}

func Benchmark_Decode_SmallStruct_Stream_JsonIter(b *testing.B) {
	b.ReportAllocs()
	reader := bytes.NewReader(SmallFixture)
	for i := 0; i < b.N; i++ {
		result := SmallPayload{}
		reader.Reset(SmallFixture)
		if err := jsoniter.NewDecoder(reader).Decode(&result); err != nil {
			b.Fatal(err)
		}
	}
}

func Benchmark_Decode_SmallStruct_Stream_GoJay(b *testing.B) {
	b.ReportAllocs()
	reader := bytes.NewReader(SmallFixture)
	for n := 0; n < b.N; n++ {
		reader.Reset(SmallFixture)
		result := SmallPayload{}
		if err := gojay.NewDecoder(reader).DecodeObject(&result); err != nil {
			b.Fatal(err)
		}
	}
}

func Benchmark_Decode_SmallStruct_Stream_SegmentioJson(b *testing.B) {
	b.ReportAllocs()
	reader := bytes.NewReader(SmallFixture)
	for i := 0; i < b.N; i++ {
		result := SmallPayload{}
		reader.Reset(SmallFixture)
		if err := segmentiojson.NewDecoder(reader).Decode(&result); err != nil {
			b.Fatal(err)
		}
	}
}

func Benchmark_Decode_SmallStruct_Stream_GoJson(b *testing.B) {
	b.ReportAllocs()
	reader := bytes.NewReader(SmallFixture)
	for i := 0; i < b.N; i++ {
		result := SmallPayload{}
		reader.Reset(SmallFixture)
		if err := gojson.NewDecoder(reader).Decode(&result); err != nil {
			b.Fatal(err)
		}
	}
}

func Benchmark_Decode_MediumStruct_Unmarshal_EncodingJson(b *testing.B) {
	b.ReportAllocs()
	for n := 0; n < b.N; n++ {
		result := MediumPayload{}
		if err := json.Unmarshal(MediumFixture, &result); err != nil {
			b.Fatal(err)
		}
	}
}

func Benchmark_Decode_MediumStruct_Unmarshal_JsonIter(b *testing.B) {
	b.ReportAllocs()
	for n := 0; n < b.N; n++ {
		result := MediumPayload{}
		if err := jsoniter.Unmarshal(MediumFixture, &result); err != nil {
			b.Fatal(err)
		}
	}
}

func Benchmark_Decode_MediumStruct_Unmarshal_EasyJson(b *testing.B) {
	b.ReportAllocs()
	for i := 0; i < b.N; i++ {
		result := NewMediumPayloadEasyJson()
		if err := result.UnmarshalJSON(MediumFixture); err != nil {
			b.Fatal(err)
		}
	}
}

func Benchmark_Decode_MediumStruct_Unmarshal_GoJay(b *testing.B) {
	b.ReportAllocs()
	for n := 0; n < b.N; n++ {
		result := MediumPayload{}
		if err := gojay.UnmarshalJSONObject(MediumFixture, &result); err != nil {
			b.Fatal(err)
		}
	}
}

func Benchmark_Decode_MediumStruct_Unmarshal_GoJayUnsafe(b *testing.B) {
	b.ReportAllocs()
	for i := 0; i < b.N; i++ {
		result := MediumPayload{}
		if err := gojay.Unsafe.UnmarshalJSONObject(MediumFixture, &result); err != nil {
			b.Fatal(err)
		}
	}
}

func Benchmark_Decode_MediumStruct_Unmarshal_SegmentioJson(b *testing.B) {
	b.ReportAllocs()
	for i := 0; i < b.N; i++ {
		result := MediumPayload{}
		if err := segmentiojson.Unmarshal(MediumFixture, &result); err != nil {
			b.Fatal(err)
		}
	}
}

func Benchmark_Decode_MediumStruct_Unmarshal_GoJson(b *testing.B) {
	b.ReportAllocs()
	for i := 0; i < b.N; i++ {
		result := MediumPayload{}
		if err := gojson.Unmarshal(MediumFixture, &result); err != nil {
			b.Fatal(err)
		}
	}
}

func Benchmark_Decode_MediumStruct_Unmarshal_GoJsonNoEscape(b *testing.B) {
	b.ReportAllocs()
	for i := 0; i < b.N; i++ {
		result := MediumPayload{}
		if err := gojson.UnmarshalNoEscape(MediumFixture, &result); err != nil {
			b.Fatal(err)
		}
	}
}

func Benchmark_Decode_MediumStruct_Stream_EncodingJson(b *testing.B) {
	b.ReportAllocs()
	reader := bytes.NewReader(MediumFixture)
	for i := 0; i < b.N; i++ {
		result := MediumPayload{}
		reader.Reset(MediumFixture)
		if err := json.NewDecoder(reader).Decode(&result); err != nil {
			b.Fatal(err)
		}
	}
}

func Benchmark_Decode_MediumStruct_Stream_JsonIter(b *testing.B) {
	b.ReportAllocs()
	reader := bytes.NewReader(MediumFixture)
	for i := 0; i < b.N; i++ {
		result := MediumPayload{}
		reader.Reset(MediumFixture)
		if err := jsoniter.NewDecoder(reader).Decode(&result); err != nil {
			b.Fatal(err)
		}
	}
}

func Benchmark_Decode_MediumStruct_Stream_GoJay(b *testing.B) {
	b.ReportAllocs()
	reader := bytes.NewReader(MediumFixture)
	for n := 0; n < b.N; n++ {
		reader.Reset(MediumFixture)
		result := MediumPayload{}
		if err := gojay.NewDecoder(reader).DecodeObject(&result); err != nil {
			b.Fatal(err)
		}
	}
}

func Benchmark_Decode_MediumStruct_Stream_SegmentioJson(b *testing.B) {
	b.ReportAllocs()
	reader := bytes.NewReader(MediumFixture)
	for n := 0; n < b.N; n++ {
		reader.Reset(MediumFixture)
		result := MediumPayload{}
		if err := segmentiojson.NewDecoder(reader).Decode(&result); err != nil {
			b.Fatal(err)
		}
	}
}

func Benchmark_Decode_MediumStruct_Stream_GoJson(b *testing.B) {
	b.ReportAllocs()
	reader := bytes.NewReader(MediumFixture)
	for i := 0; i < b.N; i++ {
		result := MediumPayload{}
		reader.Reset(MediumFixture)
		if err := gojson.NewDecoder(reader).Decode(&result); err != nil {
			b.Fatal(err)
		}
	}
}

func Benchmark_Decode_LargeStruct_Unmarshal_EncodingJson(b *testing.B) {
	b.ReportAllocs()
	for n := 0; n < b.N; n++ {
		result := LargePayload{}
		if err := json.Unmarshal(LargeFixture, &result); err != nil {
			b.Fatal(err)
		}
	}
}

func Benchmark_Decode_LargeStruct_Unmarshal_JsonIter(b *testing.B) {
	b.ReportAllocs()
	for n := 0; n < b.N; n++ {
		result := LargePayload{}
		if err := jsoniter.Unmarshal(LargeFixture, &result); err != nil {
			b.Fatal(err)
		}
	}
}

func Benchmark_Decode_LargeStruct_Unmarshal_EasyJson(b *testing.B) {
	b.ReportAllocs()
	for i := 0; i < b.N; i++ {
		result := NewLargePayloadEasyJson()
		if err := result.UnmarshalJSON(LargeFixture); err != nil {
			b.Fatal(err)
		}
	}
}

func Benchmark_Decode_LargeStruct_Unmarshal_GoJay(b *testing.B) {
	b.ReportAllocs()
	for n := 0; n < b.N; n++ {
		result := LargePayload{}
		if err := gojay.UnmarshalJSONObject(LargeFixture, &result); err != nil {
			b.Fatal(err)
		}
	}
}

func Benchmark_Decode_LargeStruct_Unmarshal_GoJayUnsafe(b *testing.B) {
	b.ReportAllocs()
	for i := 0; i < b.N; i++ {
		result := LargePayload{}
		if err := gojay.Unsafe.UnmarshalJSONObject(LargeFixture, &result); err != nil {
			b.Fatal(err)
		}
	}
}

func Benchmark_Decode_LargeStruct_Unmarshal_SegmentioJson(b *testing.B) {
	b.ReportAllocs()
	for i := 0; i < b.N; i++ {
		result := LargePayload{}
		if err := segmentiojson.Unmarshal(LargeFixture, &result); err != nil {
			b.Fatal(err)
		}
	}
}

func Benchmark_Decode_LargeStruct_Unmarshal_GoJson(b *testing.B) {
	b.ReportAllocs()
	for i := 0; i < b.N; i++ {
		result := LargePayload{}
		if err := gojson.Unmarshal(LargeFixture, &result); err != nil {
			b.Fatal(err)
		}
	}
}

func Benchmark_Decode_LargeStruct_Unmarshal_GoJsonNoEscape(b *testing.B) {
	b.ReportAllocs()
	for i := 0; i < b.N; i++ {
		result := LargePayload{}
		if err := gojson.UnmarshalNoEscape(LargeFixture, &result); err != nil {
			b.Fatal(err)
		}
	}
}

func Benchmark_Decode_LargeStruct_Stream_EncodingJson(b *testing.B) {
	b.ReportAllocs()
	reader := bytes.NewReader(LargeFixture)
	for i := 0; i < b.N; i++ {
		result := LargePayload{}
		reader.Reset(LargeFixture)
		if err := json.NewDecoder(reader).Decode(&result); err != nil {
			b.Fatal(err)
		}
	}
}

func Benchmark_Decode_LargeStruct_Stream_JsonIter(b *testing.B) {
	b.ReportAllocs()
	reader := bytes.NewReader(LargeFixture)
	for i := 0; i < b.N; i++ {
		result := LargePayload{}
		reader.Reset(LargeFixture)
		if err := jsoniter.NewDecoder(reader).Decode(&result); err != nil {
			b.Fatal(err)
		}
	}
}

func Benchmark_Decode_LargeStruct_Stream_GoJay(b *testing.B) {
	b.ReportAllocs()
	reader := bytes.NewReader(LargeFixture)
	for n := 0; n < b.N; n++ {
		reader.Reset(LargeFixture)
		result := LargePayload{}
		if err := gojay.NewDecoder(reader).DecodeObject(&result); err != nil {
			b.Fatal(err)
		}
	}
}

func Benchmark_Decode_LargeStruct_Stream_SegmentioJson(b *testing.B) {
	b.ReportAllocs()
	reader := bytes.NewReader(LargeFixture)
	for i := 0; i < b.N; i++ {
		result := LargePayload{}
		reader.Reset(LargeFixture)
		if err := segmentiojson.NewDecoder(reader).Decode(&result); err != nil {
			b.Fatal(err)
		}
	}
}

func Benchmark_Decode_LargeStruct_Stream_GoJson(b *testing.B) {
	b.ReportAllocs()
	reader := bytes.NewReader(LargeFixture)
	for i := 0; i < b.N; i++ {
		result := LargePayload{}
		reader.Reset(LargeFixture)
		if err := gojson.NewDecoder(reader).Decode(&result); err != nil {
			b.Fatal(err)
		}
	}
}