package pimport

import (
	"regexp"
	"testing"

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

func TestGenerateObjectNamePatternRegexp(t *testing.T) {
	wildcardsWorks := map[string][]string{
		`db1.tbl1`:                    {"db1.tbl1"},
		`db[0-9].tbl[0-9a-f][0-9a-f]`: {"db0.tblaa", "db0.tbla0"},
		`data.*`:                      {"data.blabla", "data.bla"},
		`*.backup_*`:                  {"hello.backup_2021"},
		`employees.*`:                 {"employees.1", "employees.1ajskldla"},
		`*.WorkOrder`:                 {"hello.WorkOrder"},
		`!*.Password`:                 {"!hello.Password"},
		`!employees.salaries`:         {"!employees.salaries"},
		`db.with.dots.*`:              {"db.with.dots.hello"},
		`"db.with.dots"."tbl\1"`:      {`"db.with.dots"."tbl\1"`},
		"`db.with.dots`.`tbl\\2`":     {"`db.with.dots`.`tbl\\2`"},
		`"foo""bar".` + "foo``bar``":  {`"foo""bar".` + "foo``bar``"},
		`foo\"bar.` + "foo\\`bar":     {`foo\"bar.` + "foo\\`bar"},
		`[0-9]`:                       {"0"},
		`[a-z]`:                       {"a"},
		`[a-z][0-9][a-z]`:             {"a0b"},
		`^%$`:                         {"^%$"},
		`^.$*`:                        {`^.$*`},
		`hello`:                       {`hello`},
		`hello.`:                      {`hello.`},
		`hello*`:                      {`hello.*`, `helloabcdksdk`},
		`hello?`:                      {`hello.`, `helloa`, `hello?`},
		`hello=world\\`:               {`hello=world\\`},
		`*hello=123?`:                 {`blabalhello=123a`},
		`*hello=123/*/abc?`:           {`*hello=123/ablablabl/abcd`},
		`*station=402260*`:            {`s3://wjktest123/mydata3/data/station=402260/part-r-00000-ddaee723-f3f6-4f25-a34b-3312172aa6d7.snappy.parquet`},
		`*station=402260*.parquet`:    {`s3://wjktest123/mydata3/data/station=402260/part-r-00000-ddaee723-f3f6-4f25-a34b-3312172aa6d7.snappy.parquet`},
		`*.parquet`:                   {`s3://wjktest123/mydata3/data/station=402265/part-r-00283-ddaee723-f3f6-4f25-a34b-3312172aa6d7.snappy.parquet`, `s3://wjktest123/mydata3/data/station=402260/part-r-00001-ddaee723-f3f6-4f25-a34b-3312172aa6d7.snappy.parquet`},
	}

	for k, vs := range wildcardsWorks {
		for _, v := range vs {
			generatedRegexp := generateObjectNamePatternRegexp(k)
			r, err := regexp.Compile(generatedRegexp)
			assert.Nil(t, err)
			assert.True(t, r.MatchString(v))
		}
	}

	wildcardsNotWorks := map[string][]string{
		"hello":      {"helloa", "hellob", "chello"},
		"hello[0-9]": {"helloa", "bhello"},
		"*hello":     {"ahellob", "hello*"},
		"hello?":     {"helloa.", "bhello"},
		"^%$":        {"^%$ww"},
		"^.$*":       {"?^*$*"},
	}
	for k, vs := range wildcardsNotWorks {
		for _, v := range vs {
			generatedRegexp := generateObjectNamePatternRegexp(k)
			r, err := regexp.Compile(generatedRegexp)
			assert.Nil(t, err)
			assert.False(t, r.MatchString(v))
		}
	}
}

func TestParseTargetTable(t *testing.T) {
	var (
		dbName    string
		tableName string
		err       error
	)

	type Resp struct {
		DBName    string
		TableName string
		ErrIsNil  bool
	}

	mapper := map[string]Resp{
		"mydb.mytable":                     {"mydb", "mytable", true},
		"`mydb.with.point`.`mytable.name`": {"`mydb.with.point`", "`mytable.name`", true},
		"abcd":                             {"", "", false},
		"sadlks*&*()":                      {"", "", false},
		"abcd.efg.hjks":                    {"abcd.efg", "hjks", true},
	}

	for k, v := range mapper {
		dbName, tableName, err = parseTargetTable(k)

		if v.ErrIsNil {
			assert.Nil(t, err)
		} else {
			assert.NotNil(t, err)
		}

		assert.Equal(t, v.DBName, dbName)
		assert.Equal(t, v.TableName, tableName)
	}
}