(ns mymymy.controllers.team
  (:require [clojure.tools.logging :as log]
            [clojure.set :as set]
            [clojure.string :as string]
            [taoensso.tufte
             :refer [defnp]])
  (:require [mymymy.models.teams :as teams]
            [mymymy.models.channel-members :as channel-members]
            [mymymy.models.users :as users]
            [mymymy.models.channels :as channels]
            [mymymy.models.events :as events]
            [mymymy.services.nimbus :as nimbus]
            [mymymy.models.messages2 :as messages2]
            [mymymy.models.virtual-channels :as vchannels]
            [mymymy.models.admins :as admins]
            [mymymy.models.team-accounts :as mta]
            [mymymy.models.rss :as rss]
            [mymymy.database :as db]
            [mymymy.context :as context]
            [mymymy.acl :as acl]
            [mymymy.deployment :as d]
            [mymymy.controllers.team-account :as cta]
            [mymymy.controllers.push :as push]
            [mymymy.controllers.channel :as channel]
            [mymymy.controllers.message2 :as message2]
            [mymymy.controllers.team :as team]
            [mymymy.controllers.user :as user]
            [mymymy.controllers.aws :as aws]
            [mymymy.corelib.utils :as u
             :refer [nil-or-empty? def-seq-n now-long]]
            [mymymy.corelib.token :as token]
            [mymymy.views.email :as email]
            [mymymy.config :as config]
            [mymymy.runtime :as rt]
            [mymymy.corelib.helper-controller :refer :all]
            [mymymy.corelib.cookie :as cookie]
            [mymymy.corelib.request :as request]
            [mymymy.corelib.resource :as resource]
            [mymymy.corelib.pinyin :as pinyin]
            [mymymy.corelib.dictionary :as dic]
            [mymymy.corelib.reserved :as reserved]
            [mymymy.modules.sms.notifications :as sms-notifications]
            [mymymy.corelib.verification :as verification]))

(def should-save-intermediate-password-in-text? (rt/on :dev :test))

(defhandler find-domain
  [identity code]
  {:pre-check [(some nil-or-empty? [identity code])
               (dic/get-message :param-required)

               (and (not (u/legal-mobile? identity))
                    (not (u/legal-email? identity)))
               (dic/get-message :param-error)]}
  (let [type :retrieve-team
        team-id nil ; no team-id is available at the moment
        code-verified? (= (str code)
                          (verification/get-code team-id type identity))]
    (if code-verified?
      (let [infos (cond ; domains to be fetched
                    (u/legal-email? identity)
                    (users/gets-team-user-by-email identity)

                    (u/legal-mobile? identity)
                    (users/gets-team-user-by-mobile identity)

                    :default nil)]
        (if-not (u/nil-or-empty? infos)
          (->> infos
               (mapv (fn [{:keys [team-name subdomain logo_url team_id] :as info}]
                       {:name team-name
                        :domain (request/build-team-domain subdomain)
                        :avatar logo_url
                        :id team_id}))
               (success))
          (fail 400 account-invalid (dic/get-message :account-invalid))))
      (fail 200 invalid-verification-code (dic/get-message :invalid-verification-code)))))

(defn create-team-and-user*
  [subdomain team_name email_domain email user_name password description mobile hide-mobile
   email-verified? mobile-verified? & [from]]
  (let [subdomain (string/lower-case subdomain)
        team (as-> (u/create-kw-map subdomain description email_domain) $
               (assoc $ :name team_name)
               (u/dissoc-if-nil-empty $ [:email_domain :description])
               (teams/create $))
        avatar (users/gen-default-avatar user_name)
        user (-> {:name            user_name
                  :avatar_url      avatar
                  :mobile          mobile
                  :email           email
                  :email_verified  email-verified?
                  :mobile_verified mobile-verified?
                  :password        (u/bcrypt password)
                  :team_id         (:id team)
                  :hide-mobile     hide-mobile
                  :role            :owner}
                 (u/dissoc-if-nil [:hide-mobile])
                 users/create)]
    (teams/set-team-from (:id team) from)
    (context/with-context {:uid (:id user) :team-id (:id team)}
      (team/after-create-team team user)
      [team user])))

(defhandler create-team-and-user
  [req subdomain team_name email_domain user_name password description code email mobile from hide_mobile]
  {:pre-check [(some
                 nil-or-empty?
                 [subdomain team_name user_name password code email mobile]) (dic/get-message :param-required)
               (not (u/legal-email? email)) (dic/get-message :illegal-email)
               (not (u/legal-mobile? mobile)) (dic/get-message :illegal-mobile)
               (team/illegal-subdomain? subdomain) (dic/get-message :illegal-subdomain)
               (reserved/reserved-subdomains subdomain) (dic/get-message :team-subdomain-reserved)
               (teams/get-by-subdomain subdomain) (dic/get-message :team-subdomain-taken)
               (reserved/reserved-email-domains email_domain) (dic/get-message :email-domain-reserved)
               (and (not (string/blank? email_domain))
                    (not (u/legal-email-domain? email_domain))) (dic/get-message :illegal-email-domain)
               (reserved/username-reserved? user_name) (dic/get-message :username-reserved)
               (not (u/legal-name? user_name)) (dic/get-message :illegal-name)]}

  (let [team-id nil ; team not created yet.
        type :create-team
        code (str code)
        email-verified? (= code (verification/get-code team-id type email))
        mobile-verified? (= code (verification/get-code team-id type mobile))
        hide-mobile (users/parse-hide-mobile hide_mobile)]
    (if (or mobile-verified? email-verified?)
      (let [[team user] (create-team-and-user* subdomain team_name email_domain
                                               email user_name password description mobile hide-mobile
                                               email-verified? mobile-verified? from)
            uid (:id user)
            identity (if email-verified? email mobile)]
        (verification/delete-code team-id type identity) ;; this nil team-id is verification code related
        (cookie/add-cookie req (success user) (:id team) uid))
      (fail 200 invalid-verification-code (dic/get-message :invalid-verification-code)))))

(defn- gen-random-passwd
  []
  (+ 100000 (rand-int 900000)))

(defn- notify-invited-users
  [uid admin team subdomain role channels identities]
  (let [{team-id :id team-name :name :keys [logo_url]} team
        invitee-base {:inviter-id uid
                      :team-id team-id
                      :role role
                      :channels channels}]
    (for [identity identities]
      (let [rand-passwd (str (gen-random-passwd))
            invitee-info (merge invitee-base {:password (u/bcrypt rand-passwd)
                                              :identity identity})]
        ;; save to team invitee list to help admin management
        (teams/save-invitee team-id identity)
        ;; save invite info to help user login
        (users/save-intermediate-user invitee-info)
        (cond (u/legal-mobile? identity)
              (sms-notifications/send-sms-notification {:type :admin-invite-user
                                                        :subdomain subdomain
                                                        :mobile identity
                                                        :password rand-passwd
                                                        :admin admin})
              (u/legal-email? identity)
              (email/async-send-invite-email-v2 identity {:subdomain subdomain
                                                          :password rand-passwd
                                                          :team team-name
                                                          :avatar (or logo_url config/teams-default-logo-url)
                                                          :admin admin}))
        ;; retun values when testting
        (when should-save-intermediate-password-in-text?
          {:account identity
           :password rand-passwd})))))

(defhandler invite-other
  [req uid team-id subdomain accounts role channels]
  {:pre-check [(some nil-or-empty? [subdomain accounts]) (dic/get-message :param-required)]}
  (let [user (users/get-by-id uid)
        team (teams/get-by-id team-id)
        accounts (->> (string/split accounts #"\s*,\s*")
                      set)
        legal-emails (set (filter u/legal-email? accounts))
        legal-mobiles (->> (set/difference accounts legal-emails)
                           (filter u/legal-mobile?)
                           set)
        illegal-accounts (set/difference accounts (set/union legal-emails legal-mobiles))
        taken-emails (delay (filter (partial users/get-by-team-id-email team-id) legal-emails))
        taken-mobiles (delay (filter (partial users/get-by-team-id-mobile team-id) legal-mobiles))]

    (cond (< 20 (count accounts))
          (fail 400 invite-too-many-same-time-code (dic/get-message :invite-too-many-same-time))

          (pos? (count illegal-accounts))
          (fail 400 email-or-mobile-illegal-code (-> (string/join "," illegal-accounts)
                                                     (str " " (dic/get-message :email-or-mobile-illegal))))

          (seq @taken-emails)
          (fail 400 email-is-taken-code (-> (string/join "," @taken-emails)
                                            (str " " (dic/get-message :email-taken))))

          (seq @taken-mobiles)
          (fail 400 mobile-is-taken-code (-> (string/join "," @taken-mobiles)
                                             (str " " (dic/get-message :mobile-taken))))

          (not (team/user-unreach-quota-limit? team-id role))
          (team/fail-user-reach-quota-limit team-id role)

          (and (= "visitor" role)
               (string/blank? channels))
          (fail 400 param-error-code (dic/get-message :param-required))

          :default
          (let [identities (map string/lower-case (concat legal-mobiles legal-emails))
                admin (:name user)]
            (-> (notify-invited-users uid admin team subdomain role channels identities)
                success)))))

(defhandler get-invitations
  "data format:
  {:account \"email or mobile\"
   :role \"normal or visitor\"
   :channels [encoded channel ids]"
  [team-id]
  (let [old-invitees (->> (teams/gets-invited-emails-with-info team-id)
                          (mapv (fn [{:keys [email] :as info}]
                                  ;; transform old invitee email key to identity key
                                  (merge (select-keys info [:role :channels])
                                         {:account email}))))
        new-invitees (->> (teams/gets-invitee-list team-id)
                          (mapv (fn [{:keys [identity]}]
                                  (when-let [info (users/get-intermediate-user
                                                   {:team-id team-id :identity identity})]
                                    (merge (select-keys info [:role :channels])
                                           {:account identity})))))]
    (->> (concat old-invitees new-invitees)
         (filter identity)
         success)))

(defhandler del-one-invitation
  [team-id account]
  {:pre-check [(nil-or-empty? account) (dic/get-message :param-required)]}
  ;; this is for old invitee
  (when (u/legal-email? account)
    (team/del-one-invitation* team-id account))
  ;; this is for new invitee
  (let [m {:team-id team-id
           :identity account}]
    (teams/del-invitee team-id account)
    (users/delete-intermediate-user m))
  (success))