package netbox

import (
	"context"
	"net"
	"testing"
	"testing/fstest"

	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/suite"
)

var (
	ipNet1 *net.IPNet
	ipNet2 *net.IPNet
	ip1    net.IP
	ip2    net.IP
)

func init() {
	_, ipNet1, _ = net.ParseCIDR("127.0.0.1/8")
	_, ipNet2, _ = net.ParseCIDR("10.0.10.0/24")
	ip1 = net.ParseIP("127.0.0.1")
	ip2 = net.ParseIP("127.0.0.2")
}

var testFs fstest.MapFS

var jsonMissingTopSiteTags = []byte(`{
	"netbox": { }
}`)

var jsonInvalidFormat = []byte(`{
	"netbox": {
		"sites": {
			"site1": {
				"invalid-tag": { "foo": "bar" }
			}
		},
		"tags": {
			"invalid-tag": { "foo": "bar" }
		}
	}
}`)

var jsonTestConfig = []byte(`{
	"netbox": {
		"sites": {
			"site1": {
				"tag1": [ "127.0.0.1/8", "10.0.10.0/24" ]
			}
		},
		"tags": {
			"tag1": [ "127.0.0.1/8", "10.0.10.0/24" ]
		}
	}
}`)

var yamlTestConfig = []byte(`
netbox:
  sites:
    site1:
      tag1: [ "127.0.0.1/8", "10.0.10.0/24" ]
      dns-servers: [ "127.0.0.1", "127.0.0.2" ]
  tags:
    tag1: [ "127.0.0.1/8", "10.0.10.0/24" ]
  services:
    testVM:
      - id: 1
        name: Test Service
        virtual_machine:
          id: 2
          name: Test VM
`)

var serviceTestConfig = []byte(`{
	"netbox": {
	}
}`)

func init() {
	testFs = fstest.MapFS{}
	testFs["netbox.foo"] = &fstest.MapFile{Data: jsonTestConfig}
	testFs["netbox.json"] = &fstest.MapFile{Data: jsonTestConfig}
	testFs["netbox.yaml"] = &fstest.MapFile{Data: yamlTestConfig}
	testFs["netbox.yml"] = &fstest.MapFile{Data: yamlTestConfig}
	testFs["no-site-tags.json"] = &fstest.MapFile{Data: jsonMissingTopSiteTags}
	testFs["invalid-format.json"] = &fstest.MapFile{Data: jsonInvalidFormat}
}

type ConfigFileNetboxClientSuite struct {
	suite.Suite
	c   NetboxClient
	nst NetboxClient
	inv NetboxClient
}

func (s *ConfigFileNetboxClientSuite) SetupTest() {
	var err error
	s.c, err = NewConfigFileClient(testFs, "netbox.yaml", "netbox")
	assert.NoError(s.T(), err)

	s.nst, err = NewConfigFileClient(testFs, "no-site-tags.json", "netbox")
	assert.NoError(s.T(), err)

	s.inv, err = NewConfigFileClient(testFs, "invalid-format.json", "netbox")
	assert.NoError(s.T(), err)
}

func (s *ConfigFileNetboxClientSuite) TestFromJSON() {
	_, err := NewConfigFileClient(testFs, "netbox.json", "netbox")
	assert.NoError(s.T(), err)
}

func (s *ConfigFileNetboxClientSuite) TestFromYAML() {
	_, err := NewConfigFileClient(testFs, "netbox.yaml", "netbox")
	assert.NoError(s.T(), err)
	_, err = NewConfigFileClient(testFs, "netbox.yml", "netbox")
	assert.NoError(s.T(), err)
}

func (s *ConfigFileNetboxClientSuite) TestFromInvalidExtension() {
	_, err := NewConfigFileClient(testFs, "netbox.foo", "netbox")
	assert.ErrorContains(s.T(), err, "extension .foo are not supported")
}

func (s *ConfigFileNetboxClientSuite) TestFromInvalidFile() {
	_, err := NewConfigFileClient(testFs, "netbox.foo-", "netbox")
	assert.ErrorContains(s.T(), err, "file does not exist")
}

func (s *ConfigFileNetboxClientSuite) TestFromInvalidKey() {
	_, err := NewConfigFileClient(testFs, "netbox.json", "netboks")
	assert.ErrorContains(s.T(), err, "Key netboks does not exist")
}

func (s *ConfigFileNetboxClientSuite) TestGetSitePrefixesWithTag() {
	ips, err := s.c.GetSitePrefixesWithTag(context.TODO(), "site1", "tag1")
	assert.NoError(s.T(), err)
	assert.Equal(s.T(), ipNet1, ips[0])
	assert.Equal(s.T(), ipNet2, ips[1])
}

func (s *ConfigFileNetboxClientSuite) TestGetSitePrefixesWithTagMissing() {
	_, err := s.nst.GetSitePrefixesWithTag(context.TODO(), "site1", "tag1")
	assert.ErrorContains(s.T(), err, "No key 'sites'")

	_, err = s.c.GetSitePrefixesWithTag(context.TODO(), "site2", "tag1")
	assert.ErrorContains(s.T(), err, "Site site2 not in sites")

	_, err = s.c.GetSitePrefixesWithTag(context.TODO(), "site1", "tag2")
	assert.ErrorContains(s.T(), err, "Tag tag2 not in tags")
}

func (s *ConfigFileNetboxClientSuite) TestGetSitePrefixesWithTagInvalid() {
	_, err := s.inv.GetSitePrefixesWithTag(context.TODO(), "site1", "invalid-tag")
	assert.ErrorContains(s.T(), err, "Key 'sites' not in correct format")
}

func (s *ConfigFileNetboxClientSuite) TestGetPrefixesWithTag() {
	ips, err := s.c.GetPrefixesWithTag(context.TODO(), "tag1")
	assert.NoError(s.T(), err)
	assert.Equal(s.T(), ipNet1, ips[0])
	assert.Equal(s.T(), ipNet2, ips[1])
}

func (s *ConfigFileNetboxClientSuite) TestGetPrefixesWithTagMissingTags() {
	_, err := s.nst.GetPrefixesWithTag(context.TODO(), "tag1")
	assert.ErrorContains(s.T(), err, "No key 'tags'")

	_, err = s.c.GetPrefixesWithTag(context.TODO(), "tag2")
	assert.ErrorContains(s.T(), err, "Tag tag2 not in tags")
}

func (s *ConfigFileNetboxClientSuite) TestGetPrefixesWithTagMissingInvalid() {
	_, err := s.inv.GetPrefixesWithTag(context.TODO(), "invalid-tag")
	assert.ErrorContains(s.T(), err, "Key 'tags' not in correct format")
}

func (s *ConfigFileNetboxClientSuite) TestGetServicesForVM() {
	svcs, err := s.c.GetServicesForVm(context.TODO(), "testVM")
	assert.NoError(s.T(), err)
	assert.Equal(s.T(), svcs[0].ID, 1)
	assert.Equal(s.T(), svcs[0].Name, "Test Service")
	assert.Equal(s.T(), svcs[0].VirtualMachine.ID, 2)
	assert.Equal(s.T(), svcs[0].VirtualMachine.Name, "Test VM")
}

func (s *ConfigFileNetboxClientSuite) TestGetServicesForVMMissingVM() {
	_, err := s.c.GetServicesForVm(context.TODO(), "foo")
	assert.ErrorContains(s.T(), err, "VM named foo not in config")
}

func (s *ConfigFileNetboxClientSuite) TestGetDnsServersForSite() {
	ips, err := s.c.GetDnsServersForSite(context.TODO(), "site1")
	assert.NoError(s.T(), err)
	assert.True(s.T(), ip1.Equal(ips[0]))
	assert.True(s.T(), ip2.Equal(ips[1]))
}

func TestConfigFileNetboxClientSuite(t *testing.T) {
	suite.Run(t, &ConfigFileNetboxClientSuite{})
}