trestle.core.generic_oscal

class GenericByComponent(TrestleBaseModel):
    """Generic ByComponent for SSP and DefinedComponent."""

    # only in SSP
    component_uuid: UuidStr = Field(
        ...,
        alias='component_uuid',
        description='A machine-oriented identifier reference to the component that is implemeting a given control.',
        title='Component Universally Unique Identifier Reference',
    )
    uuid: UuidStr = Field(
        ...,
        description='A machine-oriented, globally unique identifier with cross-instance scope that can be used to reference this by-component entry elsewhere in this or other OSCAL instances. The locally defined UUID of the by-component entry can be used to reference the data item locally or globally (e.g., in an imported OSCAL instance). This UUID should be assigned per-subject, which means it should be consistently used to identify the same subject across revisions of the document.',
        title='By-Component Universally Unique Identifier',
    )
    description: str = Field(
        ...,
        description='An implementation statement that describes how a control or a control statement is implemented within the referenced system component.',
        title='Control Implementation Description',
    )
    props: Optional[List[common.Property]] = Field(None)
    links: Optional[List[common.Link]] = Field(None)
    set_parameters: Optional[List[GenericSetParameter]] = Field(None, alias='set-parameters')
    implementation_status: Optional[common.ImplementationStatus] = Field(None, alias='implementation-status')
    # removed export, inherited, satisfied
    responsible_roles: Optional[List[common.ResponsibleRole]] = Field(None, alias='responsible-roles')
    remarks: Optional[str] = None

    @staticmethod
    def generate() -> GenericByComponent:
        """Generate instance of generic ByComponent."""
        uuid = str(uuid4())
        return GenericByComponent(
            component_uuid=const.SAMPLE_UUID_STR,
            uuid=uuid,
            description='',
            set_parameters=None,
            implementation_status=None,
            responsible_roles=None,
        )  # type: ignore[call-arg]

    def as_ssp(self) -> ossp.ByComponent:
        """Convert to ssp format."""
        set_params = []
        for set_param in as_list(self.set_parameters):
            # SetParameter may be a Union type - check for values field
            values = set_param.values if hasattr(set_param, 'values') else None
            new_set_param = ossp.SetParameter(
                **{'param-id': set_param.param_id, 'values': values, 'remarks': set_param.remarks}
            )
            set_params.append(new_set_param)
        set_params = none_if_empty(set_params)
        return ossp.ByComponent(
            **{
                'component-uuid': self.component_uuid,
                'uuid': self.uuid,
                'description': self.description,
                'props': self.props,
                'links': self.links,
                'set-parameters': set_params,
                'implementation-status': self.implementation_status,
                'responsible-roles': self.responsible_roles,
            }
        )

class GenericComponent(TrestleBaseModel):
    """Generic component for SSP SystemComponent and DefinedComponent."""

    uuid: UuidStr = Field(
        ...,
        description='A machine-oriented, globally unique identifier with cross-instance scope that can be used to reference this component elsewhere in this or other OSCAL instances. The locally defined UUID of the component can be used to reference the data item locally or globally (e.g., in an imported OSCAL instance). This UUID should be assigned per-subject, which means it should be consistently used to identify the same subject across revisions of the document.',
        title='Component Identifier',
    )
    type: NonWhitespaceStr = Field(
        ..., description='A category describing the purpose of the component.', title='Component Type'
    )
    title: str = Field(..., description='A human readable name for the component.', title='Component Title')
    description: str = Field(
        ...,
        description='A description of the component, including information about its function.',
        title='Component Description',
    )
    purpose: Optional[str] = Field(
        None, description='A summary of the technological or business purpose of the component.', title='Purpose'
    )
    props: Optional[List[common.Property]] = Field(None)
    links: Optional[List[common.Link]] = Field(None)
    responsible_roles: Optional[List[common.ResponsibleRole]] = Field(None, alias='responsible-roles')
    protocols: Optional[List[common.Protocol]] = Field(None)
    # ssp does not have a list of ci's but it does have one ci
    control_implementations: Optional[List[GenericControlImplementation]] = Field(None, alias='control-implementations')
    remarks: Optional[str] = None
    # ssp has
    status: Optional[common.ImplementationStatus] = None

    def as_defined_component(self) -> comp.DefinedComponent:
        """Convert to DefinedComponent."""
        status = self.status
        class_dict = copy.deepcopy(self.__dict__)
        class_dict.pop('status', None)
        # Clean up empty lists to avoid Pydantic v2 validation errors with min_length constraints
        # Convert empty lists to None for optional fields
        for key in class_dict.keys():
            if isinstance(class_dict[key], list) and len(class_dict[key]) == 0:
                class_dict[key] = None
        def_comp = comp.DefinedComponent(**class_dict)
        ControlInterface.insert_status_in_props(def_comp, status)  # type: ignore[type-var]
        return def_comp

    @classmethod
    def from_defined_component(cls, def_comp: comp.DefinedComponent) -> GenericComponent:
        """Convert defined component to generic."""
        status = ControlInterface.get_status_from_props(def_comp)  # type: ignore[type-var]
        class_dict = copy.deepcopy(def_comp.__dict__)
        # Ensure type is a plain string - Pydantic may store it as a constrained type
        if 'type' in class_dict:
            class_dict['type'] = str(class_dict['type'])
        if 'control_implementations' in class_dict:
            new_cis = []
            for ci in class_dict['control_implementations']:
                new_cis.append(GenericControlImplementation.from_component_ci(ci))
            class_dict['control-implementations'] = new_cis
            class_dict.pop('control_implementations', None)
        class_dict['status'] = status
        return cls(**class_dict)

    def as_system_component(self, status_override: str = '') -> common.SystemComponent:
        """Convert to SystemComponent."""
        class_dict = copy.deepcopy(self.__dict__)
        class_dict.pop('control_implementations', None)
        # Ensure type is a string - Pydantic may store it as a constrained type
        if 'type' in class_dict:
            class_dict['type'] = str(class_dict['type'])
        status_str = self.status.state if self.status else const.STATUS_OPERATIONAL
        status_str = status_override if status_override else status_str
        if status_str not in ['under-development', 'operational', 'disposition', 'other']:
            logger.warning(
                f'SystemComponent status {status_str} not recognized.  Setting to {const.STATUS_OPERATIONAL}'
            )
            status_str = const.STATUS_OPERATIONAL
        class_dict['status'] = common.Status(state=status_str, remarks=self.status.remarks)
        return common.SystemComponent(**class_dict)

    @staticmethod
    def generate() -> GenericComponent:
        """Generate instance of GenericComponent."""
        uuid = str(uuid4())
        status = common.ImplementationStatus(state=const.STATUS_OPERATIONAL)
        return GenericComponent(
            **{
                'uuid': uuid,
                'type': const.REPLACE_ME,
                'title': const.REPLACE_ME,
                'description': const.REPLACE_ME,
                'status': status,
                'purpose': None,
                'props': None,
                'links': None,
                'responsible-roles': None,
                'protocols': None,
                'control-implementations': None,
            }
        )

class GenericControlImplementation(TrestleBaseModel):
    """Generic control implementation for SSP and CompDef."""

    # not in ssp
    uuid: UuidStr = Field(
        ...,
        description='A machine-oriented, globally unique identifier with cross-instance scope that can be used to reference a set of implemented controls elsewhere in this or other OSCAL instances. The locally defined UUID of the control implementation set can be used to reference the data item locally or globally (e.g., in an imported OSCAL instance). This UUID should be assigned per-subject, which means it should be consistently used to identify the same subject across revisions of the document.',
        title='Control Implementation Set Identifier',
    )
    # not in ssp
    source: str = Field(
        ...,
        description='A reference to an OSCAL catalog or profile providing the referenced control or subcontrol definition.',
        title='Source Resource Reference',
    )
    description: str = Field(
        ...,
        description='A description of how the specified set of controls are implemented for the containing component or capability.',
        title='Control Implementation Description',
    )
    # not in ssp
    props: Optional[List[common.Property]] = Field(None)
    # not in ssp
    links: Optional[List[common.Link]] = Field(None)
    set_parameters: Optional[List[GenericSetParameter]] = Field(None, alias='set-parameters')
    implemented_requirements: List[GenericImplementedRequirement] = Field(..., alias='implemented-requirements')

    @staticmethod
    def generate() -> GenericControlImplementation:
        """Generate instance of this class."""
        uuid = str(uuid4())
        imp_reqs = [GenericImplementedRequirement.generate()]
        class_dict = {
            'uuid': uuid,
            'control-id': const.REPLACE_ME,
            'source': const.REPLACE_ME,
            'description': const.REPLACE_ME,
            'implemented-requirements': imp_reqs,
        }
        return GenericControlImplementation(**class_dict)

    @classmethod
    def from_component_ci(cls, control_imp: comp.ControlImplementation) -> GenericControlImplementation:
        """Convert component control imp to generic."""
        class_dict = copy.deepcopy(control_imp.__dict__)
        if IMPLEMENTED_REQUIREMENTS in class_dict:
            new_irs = []
            ir_list = class_dict.get(IMPLEMENTED_REQUIREMENTS, None)
            for ir in as_list(ir_list):
                new_ir = GenericImplementedRequirement.from_comp_def(ir)
                new_irs.append(new_ir)
            class_dict['implemented-requirements'] = none_if_empty(new_irs)
            class_dict.pop(IMPLEMENTED_REQUIREMENTS, None)
            new_sps = []
            sp_list = class_dict.get('set_parameters', None)
            for sp in as_list(sp_list):
                new_sps.append(GenericSetParameter.from_defined_component(sp))
            class_dict['set-parameters'] = none_if_empty(new_sps)
            class_dict.pop('set_parameters', None)

        return cls(**class_dict)

    def as_ssp(self) -> ossp.ControlImplementation:
        """Represent in ssp form."""
        imp_reqs = []
        for imp_req in self.implemented_requirements:
            imp_reqs.append(imp_req.as_ssp())
        class_dict = self.__dict__
        for prop in ['uuid', 'source', 'props', 'links', IMPLEMENTED_REQUIREMENTS]:
            class_dict.pop(prop, None)
        if imp_reqs:
            class_dict['implemented-requirements'] = imp_reqs
            class_dict.pop(IMPLEMENTED_REQUIREMENTS, None)
        return ossp.ControlImplementation(**class_dict)

class GenericImplementedRequirement(TrestleBaseModel):
    """Generic ImplementedRequirement for SSP and DefinedComponent."""

    uuid: UuidStr = Field(
        ...,
        description='A machine-oriented, globally unique identifier with cross-instance scope that can be used to reference a specific control implementation elsewhere in this or other OSCAL instances. The locally defined UUID of the control implementation can be used to reference the data item locally or globally (e.g., in an imported OSCAL instance).This UUID should be assigned per-subject, which means it should be consistently used to identify the same subject across revisions of the document.',
        title='Control Implementation Identifier',
    )
    control_id: NcNameStr = Field(
        ...,
        alias='control-id',
        description='A human-oriented identifier reference to a control with a corresponding id value. When referencing an externally defined control, the Control Identifier Reference must be used in the context of the external / imported OSCAL instance (e.g., uri-reference).',
        title='Control Identifier Reference',
    )
    # only compdef has description
    description: str = Field(
        ...,
        description='A description of how the specified control is implemented for the containing component or capability.',
        title='Control Implementation Description',
    )
    props: Optional[List[common.Property]] = Field(None)
    links: Optional[List[common.Link]] = Field(None)
    set_parameters: Optional[List[GenericSetParameter]] = Field(None, alias='set-parameters')
    responsible_roles: Optional[List[common.ResponsibleRole]] = Field(None, alias='responsible-roles')
    statements: Optional[List[GenericStatement]] = Field(None)
    remarks: Optional[str] = None
    # ssp has following
    by_components: Optional[List[GenericByComponent]] = Field(None, alias='by-components')

    @staticmethod
    def generate() -> GenericImplementedRequirement:
        """Generate instance of this class."""
        uuid = str(uuid4())
        class_dict = {'uuid': uuid, 'control-id': const.REPLACE_ME, 'description': ''}
        return GenericImplementedRequirement(**class_dict)

    @classmethod
    def from_comp_def(cls, imp_req: comp.ImplementedRequirement) -> GenericImplementedRequirement:
        """Convert component form of imp req to generic."""
        class_dict = copy.deepcopy(imp_req.__dict__)
        class_dict['control-id'] = class_dict.pop('control_id', None)
        # Convert comp.Statement objects to GenericStatement objects
        if 'statements' in class_dict and class_dict['statements']:
            generic_statements = []
            for stmt in class_dict['statements']:
                # comp.Statement and GenericStatement have the same fields, so we can convert directly
                generic_stmt = GenericStatement(**stmt.__dict__)
                generic_statements.append(generic_stmt)
            class_dict['statements'] = generic_statements
        return cls(**class_dict)

    def as_ssp(self) -> ossp.ImplementedRequirement:
        """Convert to ssp form."""
        class_dict = copy.deepcopy(self.__dict__)
        del class_dict['description']
        new_stat_list = []
        for statement in as_list(self.statements):
            new_stat_list.append(statement.as_ssp())
        if new_stat_list:
            class_dict['statements'] = new_stat_list
        # Clean up empty lists to avoid Pydantic v2 validation errors with min_length constraints
        # Convert empty lists to None for optional fields
        for key in class_dict.keys():
            if isinstance(class_dict[key], list) and len(class_dict[key]) == 0:
                class_dict[key] = None
        return ossp.ImplementedRequirement(**class_dict)

class GenericSetParameter(TrestleBaseModel):
    """Generic SetParameter for SSP and DefinedComponent."""

    param_id: NcNameStr = Field(
        ...,
        alias='param-id',
        description="A human-oriented reference to a parameter within a control, who's catalog has been imported into the current implementation context.",
        title='Parameter ID',
    )
    values: List[str] = Field(...)
    remarks: Optional[str] = None

    @staticmethod
    def from_defined_component(sp: comp.SetParameter) -> GenericSetParameter:
        """Generate generic set parameter from comp_def version."""
        class_dict = {'param-id': sp.param_id, 'values': sp.values, 'remarks': sp.remarks}
        return GenericSetParameter(**class_dict)

    def to_ssp(self) -> ossp.SetParameter:
        """Convert to ssp format."""
        return ossp.SetParameter(**{'param-id': self.param_id, 'values': self.values, 'remarks': self.remarks})

class GenericStatement(TrestleBaseModel):
    """Generic statement for SSP and DefinedComp."""

    statement_id: NcNameStr = Field(
        ...,
        alias='statement_id',
        description='A human-oriented identifier reference to a control statement.',
        title='Control Statement Reference',
    )
    uuid: UuidStr = Field(
        ...,
        description='A machine-oriented, globally unique identifier with cross-instance scope that can be used to reference this control statement elsewhere in this or other OSCAL instances. The UUID of the control statement in the source OSCAL instance is sufficient to reference the data item locally or globally (e.g., in an imported OSCAL instance).',
        title='Control Statement Reference Universally Unique Identifier',
    )
    # this is not in ssp statement
    description: str = Field(
        ...,
        description='A summary of how the containing control statement is implemented by the component or capability.',
        title='Statement Implementation Description',
    )
    props: Optional[List[common.Property]] = Field(None)
    links: Optional[List[common.Link]] = Field(None)
    responsible_roles: Optional[List[common.ResponsibleRole]] = Field(None, alias='responsible-roles')
    remarks: Optional[str] = None
    # ssp has following
    by_components: Optional[List[GenericByComponent]] = Field(None, alias='by-components')

    def as_ssp(self) -> ossp.Statement:
        """Represent in ssp form."""
        class_dict = copy.deepcopy(self.__dict__)
        class_dict.pop('description', None)
        by_comps = []
        for by_comp in as_list(self.by_components):
            new_by_comp = by_comp.as_ssp()
            by_comps.append(new_by_comp)
        # Convert empty list to None to satisfy Pydantic v2 min_length constraints
        by_comps = none_if_empty(by_comps)
        return ossp.Statement(
            **{
                'statement-id': self.statement_id,
                'uuid': self.uuid,
                'props': self.props,
                'links': self.links,
                'responsible-roles': self.responsible_roles,
                'by-components': by_comps,
                'remarks': self.remarks,
            }
        )