package models

import (
	"reflect"
	"testing"

	"github.com/k0kubun/pp"
)

func TestMergeNewVersion(t *testing.T) {
	var test = struct {
		a        Packages
		b        Packages
		expected Packages
	}{
		Packages{
			"hoge": {
				Name: "hoge",
			},
		},
		Packages{
			"hoge": {
				Name:       "hoge",
				NewVersion: "1.0.0",
				NewRelease: "release1",
			},
		},
		Packages{
			"hoge": {
				Name:       "hoge",
				NewVersion: "1.0.0",
				NewRelease: "release1",
			},
		},
	}

	test.a.MergeNewVersion(test.b)
	if !reflect.DeepEqual(test.a, test.expected) {
		e := pp.Sprintf("%v", test.a)
		a := pp.Sprintf("%v", test.expected)
		t.Errorf("expected %s, actual %s", e, a)
	}
}

func TestMerge(t *testing.T) {
	var test = struct {
		a        Packages
		b        Packages
		expected Packages
	}{
		Packages{
			"hoge": {Name: "hoge"},
			"fuga": {Name: "fuga"},
		},
		Packages{
			"hega": {Name: "hega"},
			"hage": {Name: "hage"},
		},
		Packages{
			"hoge": {Name: "hoge"},
			"fuga": {Name: "fuga"},
			"hega": {Name: "hega"},
			"hage": {Name: "hage"},
		},
	}

	actual := test.a.Merge(test.b)
	if !reflect.DeepEqual(actual, test.expected) {
		e := pp.Sprintf("%v", test.expected)
		a := pp.Sprintf("%v", actual)
		t.Errorf("expected %s, actual %s", e, a)
	}
}

func TestAddBinaryName(t *testing.T) {
	var tests = []struct {
		in       SrcPackage
		name     string
		expected SrcPackage
	}{
		{
			SrcPackage{Name: "hoge"},
			"curl",
			SrcPackage{
				Name:        "hoge",
				BinaryNames: []string{"curl"},
			},
		},
		{
			SrcPackage{
				Name:        "hoge",
				BinaryNames: []string{"curl"},
			},
			"curl",
			SrcPackage{
				Name:        "hoge",
				BinaryNames: []string{"curl"},
			},
		},
		{
			SrcPackage{
				Name:        "hoge",
				BinaryNames: []string{"curl"},
			},
			"openssh",
			SrcPackage{
				Name:        "hoge",
				BinaryNames: []string{"curl", "openssh"},
			},
		},
	}

	for _, tt := range tests {
		tt.in.AddBinaryName(tt.name)
		if !reflect.DeepEqual(tt.in, tt.expected) {
			t.Errorf("expected %#v, actual %#v", tt.in, tt.expected)
		}
	}
}

func TestFindByBinName(t *testing.T) {
	var tests = []struct {
		in       SrcPackages
		name     string
		expected *SrcPackage
		ok       bool
	}{
		{
			in: map[string]SrcPackage{
				"packA": {
					Name:        "srcA",
					BinaryNames: []string{"binA"},
					Version:     "1.0.0",
				},
				"packB": {
					Name:        "srcB",
					BinaryNames: []string{"binB"},
					Version:     "2.0.0",
				},
			},
			name: "binA",
			expected: &SrcPackage{
				Name:        "srcA",
				BinaryNames: []string{"binA"},
				Version:     "1.0.0",
			},
			ok: true,
		},
		{
			in: map[string]SrcPackage{
				"packA": {
					Name:        "srcA",
					BinaryNames: []string{"binA"},
					Version:     "1.0.0",
				},
				"packB": {
					Name:        "srcB",
					BinaryNames: []string{"binB"},
					Version:     "2.0.0",
				},
			},
			name:     "nobin",
			expected: nil,
			ok:       false,
		},
	}

	for i, tt := range tests {
		act, ok := tt.in.FindByBinName(tt.name)
		if ok != tt.ok {
			t.Errorf("[%d] expected %#v, actual %#v", i, tt.in, tt.expected)
		}
		if act != nil && !reflect.DeepEqual(*tt.expected, *act) {
			t.Errorf("[%d] expected %#v, actual %#v", i, tt.in, tt.expected)
		}
	}
}

func TestPackage_FormatVersionFromTo(t *testing.T) {
	type fields struct {
		Name             string
		Version          string
		Release          string
		NewVersion       string
		NewRelease       string
		Arch             string
		Repository       string
		Changelog        Changelog
		AffectedProcs    []AffectedProcess
		NeedRestartProcs []NeedRestartProcess
	}
	type args struct {
		stat PackageFixStatus
	}
	tests := []struct {
		name   string
		fields fields
		args   args
		want   string
	}{
		{
			name: "fixed",
			fields: fields{
				Name:       "packA",
				Version:    "1.0.0",
				Release:    "a",
				NewVersion: "1.0.1",
				NewRelease: "b",
			},
			args: args{
				stat: PackageFixStatus{
					NotFixedYet: false,
					FixedIn:     "1.0.1-b",
				},
			},
			want: "packA-1.0.0-a -> 1.0.1-b (FixedIn: 1.0.1-b)",
		},
		{
			name: "nfy",
			fields: fields{
				Name:    "packA",
				Version: "1.0.0",
				Release: "a",
			},
			args: args{
				stat: PackageFixStatus{
					NotFixedYet: true,
				},
			},
			want: "packA-1.0.0-a -> Not Fixed Yet",
		},
		{
			name: "nfy",
			fields: fields{
				Name:    "packA",
				Version: "1.0.0",
				Release: "a",
			},
			args: args{
				stat: PackageFixStatus{
					NotFixedYet: false,
					FixedIn:     "1.0.1-b",
				},
			},
			want: "packA-1.0.0-a -> Unknown (FixedIn: 1.0.1-b)",
		},
		{
			name: "nfy2",
			fields: fields{
				Name:    "packA",
				Version: "1.0.0",
				Release: "a",
			},
			args: args{
				stat: PackageFixStatus{
					NotFixedYet: true,
					FixedIn:     "1.0.1-b",
					FixState:    "open",
				},
			},
			want: "packA-1.0.0-a -> open (FixedIn: 1.0.1-b)",
		},
		{
			name: "nfy3",
			fields: fields{
				Name:    "packA",
				Version: "1.0.0",
				Release: "a",
			},
			args: args{
				stat: PackageFixStatus{
					NotFixedYet: true,
					FixedIn:     "1.0.1-b",
					FixState:    "open",
				},
			},
			want: "packA-1.0.0-a -> open (FixedIn: 1.0.1-b)",
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			p := Package{
				Name:             tt.fields.Name,
				Version:          tt.fields.Version,
				Release:          tt.fields.Release,
				NewVersion:       tt.fields.NewVersion,
				NewRelease:       tt.fields.NewRelease,
				Arch:             tt.fields.Arch,
				Repository:       tt.fields.Repository,
				Changelog:        tt.fields.Changelog,
				AffectedProcs:    tt.fields.AffectedProcs,
				NeedRestartProcs: tt.fields.NeedRestartProcs,
			}
			if got := p.FormatVersionFromTo(tt.args.stat); got != tt.want {
				t.Errorf("Package.FormatVersionFromTo() = %v, want %v", got, tt.want)
			}
		})
	}
}