# -*- coding: utf-8 -*-
"""
Tests básicos de importación y estructura de basskit.
"""

import sys
import platform
import struct


def test_importar_basskit():
	"""Verifica que basskit se puede importar correctamente."""
	import basskit
	assert hasattr(basskit, "__version__")
	assert hasattr(basskit, "diagnostico")


def test_version_definida():
	"""Verifica que la versión está definida."""
	from basskit._version import __version__
	assert isinstance(__version__, str)
	assert len(__version__) > 0


def test_excepciones_importables():
	"""Verifica que las excepciones se pueden importar."""
	from basskit.excepciones import (
		BassKitError,
		ErrorDLLNoEncontrada,
		ErrorArquitecturaInvalida,
		ErrorVersionPython,
		ErrorFuncionNoEncontrada,
		ErrorBassNativo,
	)
	# Verificar herencia
	assert issubclass(ErrorDLLNoEncontrada, BassKitError)
	assert issubclass(ErrorArquitecturaInvalida, BassKitError)
	assert issubclass(ErrorBassNativo, BassKitError)


def test_tipos_importables():
	"""Verifica que los tipos ctypes se pueden importar."""
	from basskit.tipos import (
		DWORD, QWORD, HSTREAM, HCHANNEL, HSAMPLE,
		HMUSIC, HRECORD, HSYNC, HDSP, HFX, HPLUGIN,
		version_a_texto, LOWORD, HIWORD,
	)
	assert version_a_texto(0x02041203) == "2.4.18.3"
	assert HIWORD(0x02041203) == 0x0204
	assert LOWORD(0x02041203) == 0x1203


def test_constantes_importables():
	"""Verifica que las constantes principales están definidas."""
	from basskit.constantes.bass import (
		BASS_OK, BASS_ERROR_UNKNOWN, BASS_CONFIG_BUFFER,
		BASS_STREAM_DECODE, BASS_SAMPLE_LOOP,
		BASS_ACTIVE_PLAYING, BASS_ACTIVE_STOPPED,
		BASSVERSION,
	)
	assert BASS_OK == 0
	assert BASS_ERROR_UNKNOWN == -1
	assert BASSVERSION == 0x204


def test_estructuras_importables():
	"""Verifica que las estructuras se pueden importar e instanciar."""
	from basskit.estructuras.bass import (
		BASS_DEVICEINFO, BASS_INFO, BASS_CHANNELINFO,
		BASS_3DVECTOR, BASS_SAMPLE, BASS_DX8_CHORUS,
		BASS_DX8_REVERB, TAG_ID3,
	)
	# Instanciar sin error
	info = BASS_DEVICEINFO()
	vec = BASS_3DVECTOR()
	assert vec.x == 0.0


def test_callbacks_importables():
	"""Verifica que los tipos callback se pueden importar."""
	from basskit.callbacks.bass import (
		STREAMPROC, DOWNLOADPROC, SYNCPROC, DSPPROC,
		RECORDPROC, FILECLOSEPROC, FILELENPROC,
	)


def test_diagnostico_estructura():
	"""Verifica que el diagnóstico retorna la estructura correcta."""
	import basskit
	info = basskit.diagnostico()
	assert isinstance(info, dict)
	assert "python_version" in info
	assert "plataforma" in info
	assert "arquitectura" in info
	assert "estado" in info
	assert "dlls_encontradas" in info
	assert "dlls_cargables" in info
	assert "mensajes" in info


def test_plataforma_windows():
	"""Verifica que estamos en Windows 64 bits."""
	assert platform.system() == "Windows", "basskit solo funciona en Windows"
	bits = struct.calcsize("P") * 8
	assert bits == 64, f"basskit requiere Python 64 bits (detectado: {bits})"


def test_no_x86():
	"""Verifica que no se intenta cargar DLL x86."""
	from basskit.rutas import obtener_directorio_dlls
	try:
		ruta = obtener_directorio_dlls()
		assert "x86" not in str(ruta).lower() or "x64" in str(ruta).lower()
	except FileNotFoundError:
		pass  # OK si no hay directorio (entorno sin DLL)


if __name__ == "__main__":
	# Ejecución directa para pruebas rápidas
	tests = [
		test_importar_basskit,
		test_version_definida,
		test_excepciones_importables,
		test_tipos_importables,
		test_constantes_importables,
		test_estructuras_importables,
		test_callbacks_importables,
		test_diagnostico_estructura,
		test_plataforma_windows,
		test_no_x86,
	]

	errores = 0
	for test in tests:
		try:
			test()
			print(f"  [OK] {test.__name__}")
		except Exception as e:
			print(f"  [FALLO] {test.__name__}: {e}")
			errores += 1

	print(f"\n{len(tests) - errores}/{len(tests)} tests pasaron.")
