use std::{error::Error as StdError, sync::Arc};

use async_trait::async_trait;

use chrono::TimeDelta;

use futures::TryStreamExt;

use mongodb::{

    Database,

    bson::{DateTime, Document, doc},

};

use serde::{Deserialize, Serialize};

use sylvia_iot_corelib::err::E_UNKNOWN;

use super::super::access_token::{AccessToken, AccessTokenModel, EXPIRES, QueryCond};

/// Model instance.

pub struct Model {

    /// The associated database connection.

    conn: Arc<Database>,

}

/// MongoDB schema.

#[derive(Deserialize, Serialize)]

struct Schema {

    #[serde(rename = "accessToken")]

    access_token: String,

    #[serde(rename = "refreshToken", skip_serializing_if = "Option::is_none")]

    refresh_token: Option<String>,

    #[serde(rename = "expiresAt")]

    expires_at: DateTime,

    scope: Option<String>,

    #[serde(rename = "clientId")]

    client_id: String,

    #[serde(rename = "redirectUri")]

    redirect_uri: String,

    #[serde(rename = "userId")]

    user_id: String,

    #[serde(rename = "createdAt")]

    created_at: DateTime,

}

const COL_NAME: &'static str = "accessToken";

impl Model {

    /// To create the model instance with a database connection.

}

#[async_trait]

impl AccessTokenModel for Model {

        let indexes = vec![

            doc! {"name": "accessToken_1", "key": {"accessToken": 1}, "unique": true},

            doc! {"name": "refreshToken_1", "key": {"refreshToken": 1}},

            doc! {"name": "clientId_1", "key": {"clientId": 1}},

            doc! {"name": "userId_1", "key": {"userId": 1}},

            doc! {"name": "ttl_1", "key": {"createdAt": 1}, "expireAfterSeconds": EXPIRES + 60},

        ];

        let command = doc! {

            "createIndexes": COL_NAME,

            "indexes": indexes,

        };

        self.conn.run_command(command).await?;

        Ok(())

        let mut cursor = self

            .conn

            .collection::<Schema>(COL_NAME)

            .find(doc! {"accessToken": access_token})

            .await?;

        if let Some(item) = cursor.try_next().await? {

            return Ok(Some(AccessToken {

                access_token: item.access_token,

                refresh_token: item.refresh_token,

                expires_at: item.expires_at.into(),

                scope: item.scope,

                client_id: item.client_id,

                redirect_uri: item.redirect_uri,

                user_id: item.user_id,

            }));

        }

        Ok(None)

        let item = Schema {

            access_token: token.access_token.clone(),

            refresh_token: token.refresh_token.clone(),

            expires_at: token.expires_at.into(),

            scope: token.scope.clone(),

            client_id: token.client_id.clone(),

            redirect_uri: token.redirect_uri.clone(),

            user_id: token.user_id.clone(),

            created_at: match TimeDelta::try_seconds(EXPIRES) {

                None => panic!("{}", E_UNKNOWN),

                Some(t) => (token.expires_at - t).into(),

            },

        };

        self.conn

            .collection::<Schema>(COL_NAME)

            .insert_one(item)

            .await?;

        Ok(())

        let filter = get_query_filter(cond);

        self.conn

            .collection::<Schema>(COL_NAME)

            .delete_many(filter)

            .await?;

        Ok(())

}

/// Transforms query conditions to the MongoDB document.