/*
 * Copyright (C) 2023 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package android.uwb;

import android.annotation.ElapsedRealtimeLong;
import android.annotation.IntRange;
import android.annotation.NonNull;
import android.annotation.Nullable;
import android.annotation.SystemApi;
import android.os.Parcel;
import android.os.Parcelable;
import android.uwb.UwbManager.AdapterStateCallback.State;

import java.util.Objects;

/**
 * Record of energy and activity information from controller and
 * underlying Uwb stack state. Timestamp the record with elapsed
 * real-time.
 * @hide
 */
@SystemApi
public final class UwbActivityEnergyInfo implements Parcelable {
    private final long mTimeSinceBootMillis;
    private final @State int mStackState;
    private final long mControllerTxDurationMillis;
    private final long mControllerRxDurationMillis;
    private final long mControllerIdleDurationMillis;
    private final long mControllerWakeCount;

    private UwbActivityEnergyInfo(
            @ElapsedRealtimeLong long timeSinceBootMillis,
            @State int stackState,
            @IntRange(from = 0) long txDurationMillis,
            @IntRange(from = 0) long rxDurationMillis,
            @IntRange(from = 0) long idleDurationMillis,
            @IntRange(from = 0) long wakeCount) {
        mTimeSinceBootMillis = timeSinceBootMillis;
        mStackState = stackState;
        mControllerTxDurationMillis = txDurationMillis;
        mControllerRxDurationMillis = rxDurationMillis;
        mControllerIdleDurationMillis = idleDurationMillis;
        mControllerWakeCount = wakeCount;
    }

    /**
     * @hide
     */
    @Override
    public boolean equals(@Nullable Object obj) {
        if (this == obj) {
            return true;
        }

        if (obj instanceof UwbActivityEnergyInfo) {
            UwbActivityEnergyInfo other = (UwbActivityEnergyInfo) obj;
            return mTimeSinceBootMillis == other.getTimeSinceBootMillis()
                    && mStackState == other.getStackState()
                    && mControllerTxDurationMillis == other.getControllerTxDurationMillis()
                    && mControllerRxDurationMillis == other.getControllerRxDurationMillis()
                    && mControllerIdleDurationMillis == other.getControllerIdleDurationMillis()
                    && mControllerWakeCount == other.getControllerWakeCount();
        }
        return false;
    }

    /**
     * @hide
     */
    @Override
    public int hashCode() {
        return Objects.hash(mTimeSinceBootMillis, mStackState, mControllerTxDurationMillis,
                mControllerRxDurationMillis, mControllerIdleDurationMillis, mControllerWakeCount);
    }

    @Override
    public String toString() {
        return "UwbActivityEnergyInfo{"
                + " mTimeSinceBootMillis=" + mTimeSinceBootMillis
                + " mStackState=" + mStackState
                + " mControllerTxDurationMillis=" + mControllerTxDurationMillis
                + " mControllerRxDurationMillis=" + mControllerRxDurationMillis
                + " mControllerIdleDurationMillis=" + mControllerIdleDurationMillis
                + " mControllerWakeCount=" + mControllerWakeCount
                + " }";
    }

    public static final @NonNull Creator<UwbActivityEnergyInfo> CREATOR =
            new Creator<UwbActivityEnergyInfo>() {
                @Override
                public UwbActivityEnergyInfo createFromParcel(Parcel in) {
                    Builder builder = new Builder();
                    builder.setTimeSinceBootMillis(in.readLong());
                    builder.setStackState(in.readInt());
                    builder.setControllerTxDurationMillis(in.readLong());
                    builder.setControllerRxDurationMillis(in.readLong());
                    builder.setControllerIdleDurationMillis(in.readLong());
                    builder.setControllerWakeCount(in.readLong());
                    return builder.build();
                }
                @Override
                public UwbActivityEnergyInfo[] newArray(int size) {
                    return new UwbActivityEnergyInfo[size];
                }
            };

    @Override
    public void writeToParcel(@NonNull Parcel out, int flags) {
        out.writeLong(mTimeSinceBootMillis);
        out.writeInt(mStackState);
        out.writeLong(mControllerTxDurationMillis);
        out.writeLong(mControllerRxDurationMillis);
        out.writeLong(mControllerIdleDurationMillis);
        out.writeLong(mControllerWakeCount);
    }

    @Override
    public int describeContents() {
        return 0;
    }

    /** Get the timestamp (elapsed real time milliseconds since boot) of record creation. */
    @ElapsedRealtimeLong
    public long getTimeSinceBootMillis() {
        return mTimeSinceBootMillis;
    }

    /** Get the Uwb stack reported state. */
    @State
    public int getStackState() {
        return mStackState;
    }

    /** Get the Uwb transmission duration, in milliseconds. */
    @IntRange(from = 0)
    public long getControllerTxDurationMillis() {
        return mControllerTxDurationMillis;
    }

    /** Get the Uwb receive duration, in milliseconds. */
    @IntRange(from = 0)
    public long getControllerRxDurationMillis() {
        return mControllerRxDurationMillis;
    }

    /** Get the Uwb idle duration, in milliseconds. */
    @IntRange(from = 0)
    public long getControllerIdleDurationMillis() {
        return mControllerIdleDurationMillis;
    }

    /** Get the Uwb wakeup count. */
    @IntRange(from = 0)
    public long getControllerWakeCount() {
        return mControllerWakeCount;
    }

    /**
     * Builder for a {@link UwbActivityEnergyInfo} object.
     */
    public static final class Builder {
        private long mTimeSinceBootMillis = -1L;
        private int mStackState = -1;
        private long mControllerTxDurationMillis = -1L;
        private long mControllerRxDurationMillis = -1L;
        private long mControllerIdleDurationMillis = -1L;
        private long mControllerWakeCount = -1L;

        /**
         * Set the timestamp (elapsed real time milliseconds since boot) of record creation.
         *
         * @param timeSinceBootMillis the elapsed real time since boot, in milliseconds
         */
        @NonNull
        public Builder setTimeSinceBootMillis(@ElapsedRealtimeLong long timeSinceBootMillis) {
            if (timeSinceBootMillis < 0) {
                throw new IllegalArgumentException("timeSinceBootMillis must be >= 0");
            }
            mTimeSinceBootMillis = timeSinceBootMillis;
            return this;
        }

        /**
         * Set the Uwb stack reported state.
         *
         * @param stackState Uwb stack reported state
         */
        @NonNull
        public Builder setStackState(@State int stackState) {
            if (stackState != UwbManager.AdapterStateCallback.STATE_DISABLED
                    && stackState != UwbManager.AdapterStateCallback.STATE_ENABLED_INACTIVE
                    && stackState != UwbManager.AdapterStateCallback.STATE_ENABLED_ACTIVE) {
                throw new IllegalArgumentException("invalid UWB stack state");
            }
            mStackState = stackState;
            return this;
        }

        /**
         * Set the Uwb transmission duration, in milliseconds.
         *
         * @param txDurationMillis cumulative milliseconds of active transmission
         */
        @NonNull
        public Builder setControllerTxDurationMillis(@IntRange(from = 0) long txDurationMillis) {
            if (txDurationMillis < 0) {
                throw new IllegalArgumentException("txDurationMillis must be >= 0");
            }
            mControllerTxDurationMillis = txDurationMillis;
            return this;
        }

        /**
         * Set the Uwb receive duration, in milliseconds.
         *
         * @param rxDurationMillis cumulative milliseconds of active receive
         */
        @NonNull
        public Builder setControllerRxDurationMillis(@IntRange(from = 0) long rxDurationMillis) {
            if (rxDurationMillis < 0) {
                throw new IllegalArgumentException("rxDurationMillis must be >= 0");
            }
            mControllerRxDurationMillis = rxDurationMillis;
            return this;
        }

        /**
         * Set the Uwb idle duration, in milliseconds.
         *
         * @param idleDurationMillis cumulative milliseconds when radio is awake but not
         *                           transmitting or receiving
         */
        @NonNull
        public Builder setControllerIdleDurationMillis(
                @IntRange(from = 0) long idleDurationMillis) {
            if (idleDurationMillis < 0) {
                throw new IllegalArgumentException("idleDurationMillis must be >= 0");
            }
            mControllerIdleDurationMillis = idleDurationMillis;
            return this;
        }

        /**
         * Set the Uwb wakeup count.
         *
         * @param wakeCount cumulative number of wakeup count for the radio
         */
        @NonNull
        public Builder setControllerWakeCount(@IntRange(from = 0) long wakeCount) {
            if (wakeCount < 0) {
                throw new IllegalArgumentException("wakeCount must be >= 0");
            }
            mControllerWakeCount = wakeCount;
            return this;
        }

        /**
         * Build the {@link UwbActivityEnergyInfo} object
         *
         * @throws IllegalStateException if timeSinceBootMillis, stackState, txDurationMillis,
         *                               rxDurationMillis, idleDurationMillis or wakeCount
         *                               is invalid
         */
        @NonNull
        public UwbActivityEnergyInfo build() {
            if (mTimeSinceBootMillis < 0) {
                throw new IllegalStateException(
                        "timeSinceBootMillis must be >= 0: " + mTimeSinceBootMillis);
            }

            if (mStackState != UwbManager.AdapterStateCallback.STATE_DISABLED
                    && mStackState != UwbManager.AdapterStateCallback.STATE_ENABLED_INACTIVE
                    && mStackState != UwbManager.AdapterStateCallback.STATE_ENABLED_ACTIVE) {
                throw new IllegalStateException("invalid UWB stack state");
            }

            if (mControllerTxDurationMillis < 0) {
                throw new IllegalStateException(
                        "txDurationMillis must be >= 0: " + mControllerTxDurationMillis);
            }

            if (mControllerRxDurationMillis < 0) {
                throw new IllegalStateException(
                        "rxDurationMillis must be >= 0: " + mControllerRxDurationMillis);
            }

            if (mControllerIdleDurationMillis < 0) {
                throw new IllegalStateException(
                        "idleDurationMillis must be >= 0: " + mControllerIdleDurationMillis);
            }

            if (mControllerWakeCount < 0) {
                throw new IllegalStateException(
                        "wakeCount must be >= 0: " + mControllerWakeCount);
            }

            return new UwbActivityEnergyInfo(mTimeSinceBootMillis, mStackState,
                    mControllerTxDurationMillis, mControllerRxDurationMillis,
                    mControllerIdleDurationMillis, mControllerWakeCount);
        }
    }
}