# frozen_string_literal: true

require "trust_level_repo"

class TrustLevelRepoTest < Minitest::Test
	def setup
		CustomerPlan::DB.expect(
			:query_one, {}, [String, "test"]
		)
	end

	def teardown
		assert_mock CustomerPlan::DB
	end

	def test_manual_tomb
		trust_level = TrustLevelRepo.new(
			db: FakeDB.new,
			redis: FakeRedis.new(
				"jmp_customer_trust_level-test" => "Tomb"
			)
		).find(customer(plan_name: "test_usd")).sync
		assert_equal "Manual(Tomb)", trust_level.to_s
	end
	em :test_manual_tomb

	def test_manual_cellar
		trust_level = TrustLevelRepo.new(
			db: FakeDB.new,
			redis: FakeRedis.new(
				"jmp_customer_trust_level-test" => "Cellar"
			)
		).find(customer(plan_name: "test_usd")).sync
		assert_equal "Manual(Cellar)", trust_level.to_s
	end
	em :test_manual_cellar

	def test_manual_basement
		trust_level = TrustLevelRepo.new(
			db: FakeDB.new,
			redis: FakeRedis.new(
				"jmp_customer_trust_level-test" => "Basement"
			)
		).find(customer(plan_name: "test_usd")).sync
		assert_equal "Manual(Basement)", trust_level.to_s
	end
	em :test_manual_basement

	def test_manual_customer
		trust_level = TrustLevelRepo.new(
			db: FakeDB.new,
			redis: FakeRedis.new(
				"jmp_customer_trust_level-test" => "Customer"
			)
		).find(customer(plan_name: "test_usd")).sync
		assert_equal "Manual(Customer)", trust_level.to_s
	end
	em :test_manual_customer

	def test_manual_paragon
		trust_level = TrustLevelRepo.new(
			db: FakeDB.new,
			redis: FakeRedis.new(
				"jmp_customer_trust_level-test" => "Paragon"
			)
		).find(customer(plan_name: "test_usd")).sync
		assert_equal "Manual(Paragon)", trust_level.to_s
	end
	em :test_manual_paragon

	def test_manual_unknown
		trust_level = TrustLevelRepo.new(
			db: FakeDB.new,
			redis: FakeRedis.new(
				"jmp_customer_trust_level-test" => "UNKNOWN"
			)
		).find(customer(plan_name: "test_usd")).sync
		assert_equal "Manual(Customer)", trust_level.to_s
	end
	em :test_manual_unknown

	def test_new_customer
		trust_level = TrustLevelRepo.new(
			db: FakeDB.new,
			redis: FakeRedis.new
		).find(customer(plan_name: "test_usd")).sync
		assert_kind_of TrustLevel::Cellar, trust_level
	end
	em :test_new_customer

	def test_new_customer_with_activater
		trust_level = TrustLevelRepo.new(
			db: FakeDB.new,
			redis: FakeRedis.new(
				"jmp_customer_activater-test" => "+15551234567"
			)
		).find(customer(plan_name: "test_usd")).sync
		assert_kind_of TrustLevel::Basement, trust_level
	end
	em :test_new_customer_with_activater

	def test_invited_customer
		trust_level = TrustLevelRepo.new(
			db: FakeDB.new(
				["test"] => FakeDB::MultiResult.new([{ used_at: Time.now }], [])
			),
			redis: FakeRedis.new
		).find(customer(plan_name: "test_usd")).sync
		assert_kind_of TrustLevel::Basement, trust_level
	end
	em :test_invited_customer

	def test_old_customer
		CustomerPlan::DB.query_one("", "test")
		CustomerPlan::DB.expect(
			:query_one, { start_date: Time.parse("2026-02-25") }, [String, "test"]
		)
		trust_level = TrustLevelRepo.new(
			db: FakeDB.new,
			redis: FakeRedis.new
		).find(customer(plan_name: "test_usd")).sync
		assert_kind_of TrustLevel::Basement, trust_level
	end
	em :test_old_customer

	def test_regular_customer
		trust_level = TrustLevelRepo.new(
			db: FakeDB.new(["test"] => [{ "settled_amount" => 15 }]),
			redis: FakeRedis.new(
				"jmp_customer_activater-test" => "+15551234567"
			)
		).find(customer(plan_name: "test_usd")).sync
		assert_kind_of TrustLevel::Customer, trust_level
	end
	em :test_regular_customer

	def test_settled_customer
		trust_level = TrustLevelRepo.new(
			db: FakeDB.new(["test"] => [{ "settled_amount" => 61 }]),
			redis: FakeRedis.new(
				"jmp_customer_activater-test" => "+15551234567"
			)
		).find(customer(plan_name: "test_usd")).sync
		assert_kind_of TrustLevel::Paragon, trust_level
	end
	em :test_settled_customer
end