import logging
import errno
import shutil
from coded_flows.types import Str, Path, DirectoryPath, Tuple, Union, List

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)


def _validate_source_input(src):
    """Validate that source input contains only strings and Path objects."""
    if isinstance(src, (str, Path)):
        return True
    elif isinstance(src, list):
        return all((isinstance(item, (str, Path)) for item in src))
    return False


def _copy_single_file(
    src_file, dst_file, result, overwrite, verbose, brick_display_name
):
    """Copy a single file and return True if successful."""
    try:
        if dst_file.exists() and (not overwrite):
            result["skipped_items"].append(str(src_file))
            verbose and logger.warning(
                f"[{brick_display_name}] '{src_file}' was skipped because it already exists."
            )
            return
        dst_file.parent.mkdir(parents=True, exist_ok=True)
        shutil.copy2(src_file, dst_file)
        result["copied_items"].append(str(dst_file))
        verbose and logger.info(
            f"[{brick_display_name}] The '{dst_file}' copy was created."
        )
    except OSError as e:
        if e.errno == errno.EROFS:
            verbose and logger.error(
                f"[{brick_display_name}]  Failed to copy file '{src_file}': File system is read-only."
            )
            result["errors"].append(f"Failed to copy file '{src_file}': {e}")
        else:
            verbose and logger.error(
                f"[{brick_display_name}]  Failed to copy file '{src_file}'."
            )
            result["errors"].append(f"Failed to copy file '{src_file}': {e}")
    except PermissionError as e:
        verbose and logger.error(
            f"[{brick_display_name}] Failed to copy file '{src_file}': Permission denied."
        )
        result["errors"].append(f"Failed to copy file '{src_file}': {e}")
    except Exception as e:
        verbose and logger.error(
            f"[{brick_display_name}] Failed to copy file '{src_file}'."
        )
        result["errors"].append(f"Failed to copy file '{src_file}': {e}")


def _copy_directory(src_dir, dst_dir, result, overwrite, verbose, brick_display_name):
    """Copy entire directory structure."""
    try:
        if dst_dir.exists() and (not overwrite):
            result["skipped_items"].append(str(src_dir))
            verbose and logger.warning(
                f"[{brick_display_name}] '{src_dir}' was skipped because it already exists."
            )
            return
        if dst_dir.exists() and overwrite:
            shutil.rmtree(dst_dir)
        shutil.copytree(src_dir, dst_dir)
        result["copied_items"].append(str(dst_dir))
        verbose and logger.info(
            f"[{brick_display_name}] The '{dst_dir}' copy was created."
        )
    except OSError as e:
        if e.errno == errno.EROFS:
            verbose and logger.error(
                f"[{brick_display_name}]  Failed to copy file '{src_dir}': File system is read-only."
            )
            result["errors"].append(f"Failed to copy file '{src_dir}': {e}")
        else:
            verbose and logger.error(
                f"[{brick_display_name}]  Failed to copy file '{src_dir}'."
            )
            result["errors"].append(f"Failed to copy file '{src_dir}': {e}")
    except PermissionError as e:
        verbose and logger.error(
            f"[{brick_display_name}] Failed to copy file '{src_dir}': Permission denied."
        )
        result["errors"].append(f"Failed to copy file '{src_dir}': {e}")
    except Exception as e:
        verbose and logger.error(
            f"[{brick_display_name}] Failed to copy file '{src_dir}'."
        )
        result["errors"].append(f"Failed to copy file '{src_dir}': {e}")


def copy_files(
    source: Union[Str, Path, List], destination: Union[Str, DirectoryPath], options=None
) -> Tuple[List, List, List]:
    brick_display_name = "Copy"
    options = options or {}
    verbose = options.get("verbose", True)
    overwrite = options.get("overwrite", True)
    result = {"copied_items": [], "skipped_items": [], "errors": []}
    if not _validate_source_input(source):
        verbose and logger.error(
            f"[{brick_display_name}] Invalid source input. Must be Str, Path, or list of Str/Path objects."
        )
        raise ValueError(
            "Invalid source input. Must be Str, Path, or list of Str/Path objects."
        )
    if isinstance(source, (str, Path)):
        source_paths = [Path(source)]
    else:
        source_paths = source
    destination_path = Path(destination)
    try:
        destination_path.mkdir(parents=True, exist_ok=True)
    except PermissionError as e:
        verbose and logger.error(
            f"[{brick_display_name}] Failed to create destination directory '{destination_path}': Permission denied."
        )
        raise PermissionError(
            f"Failed to create destination directory '{destination_path}': Permission denied."
        )
    except Exception as e:
        verbose and logger.error(
            f"[{brick_display_name}] Failed to create destination directory."
        )
        raise OSError(f"Failed to create destination directory: {e}")
    for source_item in source_paths:
        src_path = Path(source_item)
        if not src_path.exists():
            result["errors"].append(f"Source path does not exist: '{source_item}'.")
            verbose and logger.error(
                f"[{brick_display_name}] Source path does not exist: '{source_item}'."
            )
            continue
        dst_path = destination_path / src_path.name
        if src_path.is_file():
            _copy_single_file(
                src_path, dst_path, result, overwrite, verbose, brick_display_name
            )
        elif src_path.is_dir():
            _copy_directory(
                src_path, dst_path, result, overwrite, verbose, brick_display_name
            )
        else:
            verbose and logger.error(
                f"[{brick_display_name}] Unknown file type: '{source_item}'."
            )
            result["errors"].append(f"Unknown file type: '{source_item}'.")
    copied_items = result["copied_items"]
    skipped_items = result["skipped_items"]
    errors = result["errors"]
    return (copied_items, skipped_items, errors)