"""
Fitbit Web API Explorer

Fitbit provides a Web API for accessing data from Fitbit activity trackers, Aria scale, and manually entered logs. Anyone can develop an application to access and modify a Fitbit user's data on their behalf, so long as it complies with Fitbit Platform Terms of Service. These Swagger UI docs do not currently support making Fitbit API requests directly. In order to make a request, construct a request for the appropriate endpoint using this documentation, and then add an Authorization header to each request with an access token obtained using the steps outlined here: https://dev.fitbit.com/build/reference/web-api/developer-guide/authorization/.

The version of the OpenAPI document: 1
Generated by OpenAPI Generator (https://openapi-generator.tech)

Do not edit the class manually.
"""  # noqa: E501

from __future__ import annotations

import json
import pprint
import re  # noqa: F401
from datetime import datetime
from typing import Any, ClassVar, Dict, List, Optional, Set

from pydantic import BaseModel, ConfigDict, Field, StrictInt, StrictStr, field_validator
from typing_extensions import Self


class EcgReading(BaseModel):
    """
    EcgReading
    """

    start_time: Optional[datetime] = Field(
        default=None,
        description="The date and time when the reading was started on the device.",
        alias="startTime",
    )
    average_heart_rate: Optional[StrictInt] = Field(
        default=None,
        description="The average heart rate of the user during the reading.",
        alias="averageHeartRate",
    )
    result_classification: Optional[StrictStr] = Field(
        default=None,
        description="The classification of the ECG result.",
        alias="resultClassification",
    )
    waveform_samples: Optional[List[StrictInt]] = Field(
        default=None,
        description="An array of integers representing the ECG waveform.",
        alias="waveformSamples",
    )
    sampling_frequency_hz: Optional[StrictInt] = Field(
        default=None,
        description="The frequency in hertz at which the Fitbit ECG app sampled the voltage.",
        alias="samplingFrequencyHz",
    )
    scaling_factor: Optional[StrictInt] = Field(
        default=None,
        description="The scaling factor used to convert waveform samples to ECG voltages in mV (mV = waveformSamples / scalingFactor).",
        alias="scalingFactor",
    )
    number_of_waveform_samples: Optional[StrictInt] = Field(
        default=None,
        description="The total number of samples in the reading.",
        alias="numberOfWaveformSamples",
    )
    lead_number: Optional[StrictInt] = Field(
        default=None,
        description="The ECG lead being used to take the reading.",
        alias="leadNumber",
    )
    feature_version: Optional[StrictStr] = Field(
        default=None,
        description="The version of the ECG app running on the device.",
        alias="featureVersion",
    )
    device_name: Optional[StrictStr] = Field(
        default=None,
        description="Hardware name of the compatible wrist-worn device used to take the reading.",
        alias="deviceName",
    )
    firmware_version: Optional[StrictStr] = Field(
        default=None,
        description="Firmware running on the compatible wrist-worn device used to take the reading.",
        alias="firmwareVersion",
    )
    __properties: ClassVar[List[str]] = [
        "startTime",
        "averageHeartRate",
        "resultClassification",
        "waveformSamples",
        "samplingFrequencyHz",
        "scalingFactor",
        "numberOfWaveformSamples",
        "leadNumber",
        "featureVersion",
        "deviceName",
        "firmwareVersion",
    ]

    @field_validator("result_classification")
    def result_classification_validate_enum(cls, value):
        """Validates the enum"""
        if value is None:
            return value

        if value not in set(
            [
                "Atrial Fibrillation",
                "Normal Sinus Rhythm",
                "Inconclusive",
                "Inconclusive: High heart rate",
                "Inconclusive: Low heart rate",
            ]
        ):
            raise ValueError(
                "must be one of enum values ('Atrial Fibrillation', 'Normal Sinus Rhythm', 'Inconclusive', 'Inconclusive: High heart rate', 'Inconclusive: Low heart rate')"
            )
        return value

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )

    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of EcgReading from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """
        Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of EcgReading from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate(
            {
                "startTime": obj.get("startTime"),
                "averageHeartRate": obj.get("averageHeartRate"),
                "resultClassification": obj.get("resultClassification"),
                "waveformSamples": obj.get("waveformSamples"),
                "samplingFrequencyHz": obj.get("samplingFrequencyHz"),
                "scalingFactor": obj.get("scalingFactor"),
                "numberOfWaveformSamples": obj.get("numberOfWaveformSamples"),
                "leadNumber": obj.get("leadNumber"),
                "featureVersion": obj.get("featureVersion"),
                "deviceName": obj.get("deviceName"),
                "firmwareVersion": obj.get("firmwareVersion"),
            }
        )
        return _obj
