import argparse
import asyncio
import logging
from pathlib import Path

from maven import get_effective_packages
from config import parse_config, Configuration
from gradle import create_gradle_build, create_gradle_settings
from maven.plugins import get_effective_plugins

logger = logging.getLogger(__name__)


async def resolve_kotlin(ident: str, configuration: Configuration, output_dir: Path, mirrors: list[str], gradle_repo: str):
    resolved_packages = set([
        resolved
        for package in configuration.packages
        for resolved in await get_effective_packages(package, mirrors)
    ])

    resolved_plugins = set([
        resolved
        for plugin in configuration.plugins
        for resolved in await get_effective_plugins(plugin, mirrors)
    ])

    gradle_path = configuration.gradle_version or "default"
    path = output_dir / f"{gradle_path}/{ident}-kotlin-{configuration.kotlin_version}"
    path.mkdir(parents=True)
    logger.debug(f'Creating {path}')

    logger.debug('Generating build.gradle.kts')
    gradle_build = create_gradle_build(configuration.kotlin_version, resolved_plugins, resolved_packages, gradle_repo)
    (path / 'build.gradle.kts').write_text(gradle_build)

    logger.debug('Generating settings.gradle.kts')
    gradle_settings = create_gradle_settings(gradle_repo)
    (path / 'settings.gradle.kts').write_text(gradle_settings)


async def main(package_list: Path, output_dir: Path, gradle_repo: str) -> None:
    config = parse_config(package_list)

    if not config:
        print('Error in configuration')
    elif not config.configurations:
        print('No configurations defined, nothing to do.')
    elif not config.mirrors:
        print('No mirrors defined. Add maven.mirrors in the config file.')
    else:
        for i, configuration in enumerate(config.configurations):
            logger.info(f'Resolving kotlin {configuration.kotlin_version}')
            try:
                await resolve_kotlin(str(i), configuration, output_dir, config.mirrors, gradle_repo)
            except:
                logger.exception(f'Error resolving kotlin version {configuration.kotlin_version}')


if __name__ == '__main__':
    parser = argparse.ArgumentParser()
    parser.add_argument('-v', '--verbose', dest='verbosity', action='count', default=0)
    parser.add_argument('--repo', type=str, help="The repository gradle should use", required=True)
    parser.add_argument('--output-dir', type=Path, help="The directory to put the generated gradle files in",
                        default=Path('..'), required=False)
    parser.add_argument('package_list', type=Path, help="The list of packages to download")
    args = parser.parse_args()

    if args.verbosity == 0:
        log_level = 'WARNING'
    elif args.verbosity == 1:
        log_level = 'INFO'
    else:
        log_level = 'DEBUG'

    logging.basicConfig(level=log_level)

    asyncio.run(
        main(args.package_list, args.output_dir, args.repo)
    )