#include "mobile_session.h"
#include "media.h"
#include "audio.h"
#include "key_mapping.h"
#include <app_version.h>
#include <mobile_controller_protocol.h>
#include <mobile_file_transfer_session.h>
#include <mobile_video_timing.h>
#include <display_stream_id.h>
#include <log.h>
#include <libyuv.h>
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <fstream>
#include <memory>
#include <set>

namespace crossdesk::harmony {
namespace {
using json = nlohmann::json;
using Clock = std::chrono::steady_clock;
// A separate controller-only entry point. No Capture, Input, AddVideoStream,
// host input handler or screen-recording authorization exists in this session.
class MobileSession {
 public:
  MobileSession() : renderer_([this](const uint8_t* pixels, int w, int h, uint64_t captured,
                                    uint64_t received, uint64_t generation) {
    const auto session = session_.load(), connection = connection_.load();
    if (!connected_ || generation != video_generation_) return;
    const auto now = std::chrono::duration_cast<std::chrono::microseconds>(Clock::now().time_since_epoch()).count();
    // MiniRTC uses its own monotonic clock; the offset is sampled on its worker.
    const double latency = mobile_controller::VideoLatencyMilliseconds(captured, received, now + clock_offset_);
    Event({{"type", "frame"}, {"width", w}, {"height", h}, {"latency", latency}, {"frame", ++frame_id_},
           {"videoGeneration", generation}, {"session", session}, {"connection", connection}}, true);
    std::string path;
    uint64_t preview_epoch;
    { std::lock_guard lock(preview_mutex_); path.swap(preview_path_); preview_epoch = preview_epoch_; }
    if (path.empty()) return;
    // Only the decoded video is sampled, never the device screen or controls.
    // Downscale YUV first: a 4K/8K desktop must not allocate a full-size RGBA copy on a phone.
    std::vector<uint8_t> scaled(640 * 360 * 3 / 2), preview(640 * 360 * 4);
    const int cw = std::min(w, (h * 16 / 9) & ~1), ch = std::min(h, (w * 9 / 16) & ~1);
    const int left = ((w-cw)/2)&~1, top = ((h-ch)/2)&~1;
    bool ok = cw > 0 && ch > 0 && libyuv::NV12Scale(pixels+size_t(top)*w+left,w,
      pixels+size_t(w)*h+size_t(top/2)*w+left,w,cw,ch,scaled.data(),640,
      scaled.data()+640*360,640,640,360,libyuv::kFilterBilinear) == 0;
    if (ok) ok = libyuv::NV12ToABGR(scaled.data(),640,scaled.data()+640*360,640,preview.data(),640*4,640,360) == 0;
    std::lock_guard lock(preview_mutex_);
    if (ok && connected_ && generation == video_generation_ && preview_epoch == preview_epoch_) {
      std::ofstream out(path, std::ios::binary | std::ios::trunc);
      out.write(reinterpret_cast<const char*>(preview.data()), preview.size()); out.close(); ok = bool(out);
    } else ok = false;
    if (!ok) std::remove(path.c_str());
    Event({{"type", "preview"}, {"path", path}, {"ok", ok}, {"videoGeneration", generation},
           {"session", session}, {"connection", connection}}, true);
  }), worker_([this] { Run(); }) {}
  ~MobileSession() {
    { std::lock_guard lock(queue_mutex_); stopping_ = true; pending_.clear(); ready_.notify_one(); }
    worker_.join();
  }
  void Queue(std::function<void()> fn) {
    std::lock_guard lock(queue_mutex_);
    if (!stopping_ && pending_.size() < 8192) { pending_.push_back(std::move(fn)); ready_.notify_one(); }
  }
  void Command(std::string text) { Queue([this, text = std::move(text)] { Execute(json::parse(text)); }); }
  std::string Poll() {
    std::lock_guard lock(events_mutex_);
    auto value = events_.dump(-1, ' ', false, json::error_handler_t::replace); events_ = json::array(); return value;
  }
 private:
  struct Context { MobileSession* owner; bool controller; uint64_t generation; };
  void Event(json value, bool controller = false) {
    if (!value.contains("session")) value["session"] = session_.load();
    if (controller && !value.contains("connection")) value["connection"] = connection_.load();
    std::lock_guard lock(events_mutex_);
    // Coalesce high-frequency samples, never displace identity/password or terminal events.
    if (value["type"] == "frame") value["latencyCount"] = value["latency"].get<double>() >= 0 ? 1 : 0;
    if (value["type"] == "frame" || value["type"] == "network") {
      for (auto it = events_.begin(); it != events_.end();) {
        if ((*it)["type"] == value["type"]) {
          if (value["type"] == "frame" && (*it)["session"] == value["session"] &&
              (*it)["connection"] == value["connection"] && (*it)["videoGeneration"] == value["videoGeneration"]) {
            const int previous = it->value("latencyCount", 0), count = value["latencyCount"];
            if (previous + count > 0) value["latency"] =
              (it->value("latency", 0.) * previous + value["latency"].get<double>() * count) / (previous + count);
            value["latencyCount"] = previous + count;
          }
          it = events_.erase(it);
        } else ++it;
      }
    }
    if (events_.size() < 1024) events_.push_back(std::move(value));
  }
  bool Current(bool controller, uint64_t generation) const {
    return generation == (controller ? connection_.load() : session_.load());
  }
  template<typename F> static void Dispatch(void* user, F fn) {
    auto* c = static_cast<Context*>(user); auto* self = c->owner;
    self->Queue([self, controller = c->controller, generation = c->generation, fn] {
      if (self->Current(controller, generation)) fn(self, controller);
    });
  }
  static void Signal(SignalStatus status, const char*, size_t, void* user) {
    Dispatch(user, [status](MobileSession* s, bool controller) {
      if (!controller) {
        s->online_ = status == SignalConnected;
        if (s->signal_status_ != status) {
          ++s->signal_generation_;
          if (s->signal_status_ == SignalConnected) s->signal_started_ = Clock::now();
        }
        s->signal_status_ = status;
        if (s->online_) {
          constexpr char info[] = R"({"type":"client_info","version":"harmony-mobile","platform":"harmonyos"})";
          SendSignalMessage(s->identity_, info, sizeof(info)-1);
        }
      }
      s->Event({{"type", "signal"}, {"controller", controller}, {"status", status},
                {"generation", s->signal_generation_}, {"id", s->login_.substr(0, s->login_.find('@'))}});
      if (controller && status >= SignalFailed && status != SignalReconnecting) s->Disconnect("远程会话信令连接失败");
    });
  }
  static void SignalMessage(const char* data, size_t size, void* user) {
    if (!data || size > 1024*1024) return;
    const auto value = json::parse(data, data+size, nullptr, false);
    if (!value.is_object()) return;
    Dispatch(user, [value](MobileSession* s, bool controller) {
      if (controller || !s->online_) return;
      const auto type = value.value("type", "");
      if (type == "announcements" || type == "announcements_changed" || type == "presence" || type == "presence_update")
        s->Event({{"type", "signalMessage"}, {"message", value}, {"generation", s->signal_generation_}});
    });
  }
  static void Connection(ConnectionStatus status, const char* id, size_t size, void* user) {
    const std::string remote(id ? id : "", id ? size : 0);
    Dispatch(user, [status, remote](MobileSession* s, bool controller) {
      if (!controller) {
        // Defense in depth if a server tries to attach a guest to our identity.
        if (status == Connected && s->identity_)
          DisconnectPeerConnection(s->identity_, s->login_.substr(0,s->login_.find('@')).c_str(), remote.c_str());
        return;
      }
      s->Event({{"type", "connection"}, {"status", status}}, true);
      if (status == Connected && !s->connected_) {
        s->connecting_ = false; s->connected_ = true;
        auto info = MakeHostInformation("CrossDesk HarmonyOS Mobile", {}, false, s->version_, HostPlatform::HarmonyOS);
        s->Send(info); FreeRemoteAction(info);
        RemoteAction audio{}; audio.type = audio_capture; audio.a = !s->muted_; s->Send(audio);
        s->audio_.Start();
      } else if (status >= Disconnected) s->Disconnect("");
    });
  }
  static void Network(const char* id, size_t size, TraversalMode mode, const MiniRtcNetTrafficStats* stats,
                      const char*, size_t, void* user) {
    if (mode == UnknownMode && id && size) {
      const std::string login(id, size);
      Dispatch(user, [login](MobileSession* s, bool controller) {
        if (!controller) {
          // Reconnect reports may contain only the public ID. Never replace a
          // usable ID@password with that public-only report (same as Android).
          if (login.find('@') != std::string::npos || s->login_.rfind(login + "@", 0) != 0) s->login_ = login;
          s->Event({{"type", "identity"}, {"identity", s->login_}});
        }
      });
    } else if (stats) {
      auto report = mobile_controller::NetworkReport(*stats, mode);
      Dispatch(user, [report](MobileSession* s, bool controller) {
        if (controller && s->connected_) s->Event({{"type", "network"}, {"report", report}}, true);
      });
    }
  }
  static void Data(const char* data, size_t size, const char*, size_t, const char* stream, size_t length, void* user) {
    if (!data || !stream || size > 1024*1024) return;
    const std::string bytes(data,size), name(stream,length);
    Dispatch(user, [bytes,name](MobileSession* s, bool controller) {
      // The data channel can deliver host information/file chunks before the
      // local ICE Connected notification. Keep those authenticated packets.
      if (!controller || (!s->connected_ && !s->connecting_)) return;
      if (name == kFileStream && s->files_) s->files_->Receive(bytes.data(), bytes.size());
      else if (name == kFileFeedbackStream && s->files_) s->files_->Ack(bytes.data(), bytes.size());
      else if (name == kClipboardStream && bytes.size() <= kMaxClipboardBytes)
        s->Event({{"type", "clipboard"}, {"text", bytes}}, true);
      else if (name == kControlStream) {
        RemoteAction action{};
        if (action.from_json(bytes)) {
          const auto value = json::parse(action.to_json()); FreeRemoteAction(action);
          s->Event({{"type", "data"}, {"message", value}}, true);
        }
      }
    });
  }
  static void Video(const MiniRtcVideoFrame* frame, const char*, size_t, const char* stream, size_t size, void* user) {
    auto* c = static_cast<Context*>(user); auto* s = c->owner;
    if (c->controller && c->generation == s->connection_ && s->connected_ && !s->suspended_ && frame && stream &&
        std::string(stream,size) == MakeDisplayStreamId(s->display_)) s->renderer_.Video(*frame, s->video_generation_);
  }
  static void Audio(const char* data, size_t size, const char*, size_t, const char*, size_t, void* user) {
    auto* c = static_cast<Context*>(user); auto* s = c->owner;
    if (c->controller && c->generation == s->connection_ && s->connected_ && !s->muted_ && !s->suspended_) s->audio_.Push(data,size);
  }
  Params Parameters(bool controller) {
    Params p{};
    std::snprintf(p.signal_server_ip,sizeof(p.signal_server_ip),"%s",server_.c_str());
    std::snprintf(p.log_path,sizeof(p.log_path),"%s",logs_.c_str());
    p.signal_server_port = port_; p.enable_srtp = true; p.turn_mode = TurnAutoUdpTcp;
    p.video_content_type = VideoContentType::ScreenContent; p.video_quality = QualityMedium; p.video_frame_rate = 30;
    p.video_degradation_preference = VideoDegradationPreference::MaintainResolution;
    p.hardware_acceleration = true;
    p.user_id = controller ? controller_login_.c_str() : login_.c_str();
    p.user_data = controller ? control_context_.get() : identity_context_.get();
    p.on_signal_status = Signal; p.on_signal_message = SignalMessage; p.on_connection_status = Connection;
    p.on_net_status_report = Network; p.on_receive_data_buffer = Data; p.on_receive_video_frame = Video; p.on_receive_audio_buffer = Audio;
    return p;
  }
  void Send(const RemoteAction& action, const char* stream = kControlStream) {
    if (!controller_) return;
    const auto bytes = action.to_json(); SendReliableDataFrame(controller_,bytes.data(),bytes.size(),stream);
  }
  void Release() {
    for (int key : keys_) { RemoteAction a{}; a.type=keyboard; a.k={size_t(key),0,false,key_up}; Send(a,kKeyboardStream); }
    for (int i=0;i<3;i++) if (buttons_ & (1u<<i)) {
      RemoteAction a{}; a.type=mouse; a.m={x_,y_,0,static_cast<MouseFlag>(2+i*2)}; Send(a,kMouseStream);
    }
    keys_.clear(); buttons_=0;
  }
  void CancelPreview() {
    std::lock_guard lock(preview_mutex_); preview_path_.clear(); ++preview_epoch_;
    std::error_code error;
    if (preview_directory_.empty()) return;
    for (const auto& file : std::filesystem::directory_iterator(preview_directory_, error)) {
      const auto name = file.path().filename().string();
      if (name.rfind("preview-", 0) == 0 && file.path().extension() == ".rgba") std::filesystem::remove(file.path(), error);
    }
  }
  void Disconnect(const std::string& reason) {
    const bool active = controller_ != nullptr;
    Release(); connected_=false; connecting_=false; ++video_generation_;
    CancelPreview();
    if (controller_) { LeaveConnection(controller_,remote_.c_str()); DestroyPeer(&controller_); }
    files_.reset(); renderer_.Clear(); audio_.Stop();
    if (active) Event({{"type","ended"},{"reason",reason}},true);
    ++connection_; display_=0; frame_id_=0;
  }
  void Stop() {
    Disconnect(""); online_=false;
    if (identity_) DestroyPeer(&identity_);
    ++session_; login_.clear(); signal_status_=-1;
  }
  void Execute(const json& v) {
    const auto op=v.at("op").get<std::string>();
    if (op=="start") {
      Stop(); session_=v.at("session").get<uint64_t>();
      server_=v.at("server").get<std::string>(); port_=v.at("port").get<int>();
      logs_=v.at("logs").get<std::string>(); login_=v.value("identity",""); version_=v.value("version","0.1.0");
      const auto roots=v.at("certificates").get<std::string>(); directory_=v.at("directory").get<std::string>();
      preview_directory_=v.at("previewDirectory").get<std::string>();
      if (server_.empty()||server_.size()>=256||server_.find('@')!=std::string::npos||port_<1||port_>65535||
          logs_.size()>=256||roots.empty()||directory_.empty()) throw std::runtime_error("Invalid configuration");
      setenv("SSL_CERT_DIR",roots.c_str(),1); minirtc::InitLogger(logs_); minirtc::get_logger()->set_level(spdlog::level::off);
      identity_context_=std::make_unique<Context>(Context{this,false,session_});
      auto p=Parameters(false); identity_=CreatePeer(&p); signal_started_=Clock::now();
      if (!identity_||Init(identity_)!=0) { throw std::runtime_error("Identity initialization failed"); }
    } else if (op=="stop") Stop();
    else if (op=="version") {
      const auto body=v.at("body").get<std::string>(), current=v.value("version","");
      const bool local=v.value("local",false);
      std::optional<std::string> result;
      if (local) result=CheckPlatformAppUpdate(current,body,"harmony-arm64");
      else if (const auto release=ParseVersionInfoJSON(body)) result=AvailableAppUpdate(current,*release).value_or("");
      Event({{"type","version"},{"request",v.at("request")},{"ok",result.has_value()},{"latest",result.value_or("")}});
    } else if (op=="surface") renderer_.Surface(std::stoull(v.value("id","0")));
    else if (op=="connect") {
      if (!online_||login_.empty()) throw std::runtime_error("Not signed in");
      Disconnect(""); connection_=v.at("connection").get<uint64_t>();
      remote_=v.at("remote").get<std::string>(); const auto password=v.at("password").get<std::string>();
      if (remote_.size()!=9||!std::all_of(remote_.begin(),remote_.end(),::isdigit)||password.size()>128||password.find('@')!=std::string::npos)
        throw std::runtime_error("Invalid remote credentials");
      muted_=false; suspended_=false; controller_login_="C-"+login_.substr(0,login_.find('@'));
      control_context_=std::make_unique<Context>(Context{this,true,connection_});
      auto p=Parameters(true); controller_=CreatePeer(&p); connecting_=true; connection_started_=Clock::now();
      if (!controller_) throw std::runtime_error("Peer creation failed");
      AddAudioStream(controller_,kAudioStream); AddDataStream(controller_,kDataStream,false);
      for (auto stream : {kMouseStream,kKeyboardStream,kControlStream,kClipboardStream,kFileStream,kFileFeedbackStream})
        AddDataStream(controller_,stream,true);
      files_=std::make_unique<mobile_controller::FileTransferSession>(
        [this](const char* stream,const char* data,size_t size) { return controller_?SendReliableDataFrame(controller_,data,size,stream):-1; },
        [this](const std::string& name,double progress,bool sending,const std::string& path) {
          Event({{"type","file"},{"name",name},{"progress",progress},{"sending",sending},{"path",path}},true);
        });
      files_->SetDirectory(directory_+"/received");
      if (Init(controller_)!=0||JoinConnection(controller_,(remote_+"@"+password).c_str())!=0) Disconnect("无法发起连接");
    } else if (op=="disconnect") Disconnect("");
    else if (op=="release") Release();
    else if (op=="signal" && online_ && identity_) {
      auto request=v.at("message"); const auto type=request.value("type","");
      if (type!="announcements_list"&&type!="recent_connections_presence") return;
      request["user_id"]=login_.substr(0,login_.find('@'));
      const auto bytes=request.dump(); const bool ok=SendSignalMessage(identity_,bytes.data(),bytes.size())==0;
      if (!ok) Event({{"type","requestFailed"},{"request",request.value("request_id","")}});
    } else if (connected_) {
      if (op=="pointer") {
        const int flag=v.at("flag").get<int>(); const float x=v.at("x").get<float>(),y=v.at("y").get<float>();
        if (flag<0||flag>8||!std::isfinite(x)||!std::isfinite(y)) return;
        x_=std::clamp(x,0.f,1.f); y_=std::clamp(y,0.f,1.f);
        if (flag>=1&&flag<=6) { unsigned bit=1u<<((flag-1)/2); if (flag&1) buttons_|=bit; else buttons_&=~bit; }
        RemoteAction a{}; a.type=mouse; a.m={x_,y_,std::clamp(v.value("scroll",0),-120,120),static_cast<MouseFlag>(flag)}; Send(a,kMouseStream);
      } else if (op=="key"||op=="virtualKey") {
        const int key=op=="key"?ToVirtualKey(v.at("code").get<int>()):v.at("code").get<int>();
        if (key<=0||key>255) return;
        const bool down=v.at("down").get<bool>(); if (down) keys_.insert(key); else keys_.erase(key);
        RemoteAction a{}; a.type=keyboard; a.k={size_t(key),0,false,down?key_down:key_up}; Send(a,kKeyboardStream);
      } else if (op=="display") {
        const int index=v.at("index").get<int>(); if(index<0||index>=32)return;
        Release(); display_=index; ++video_generation_; renderer_.Clear();
        RemoteAction a{}; a.type=display_id; a.d=index; Send(a);
      } else if (op=="visible") {
        suspended_=!v.at("visible").get<bool>();
        if (suspended_) { renderer_.Clear(); audio_.Stop(); } else if (!muted_) audio_.Start();
      } else if (op=="mute") {
        muted_=v.at("muted").get<bool>(); if (muted_||suspended_) audio_.Stop(); else audio_.Start();
        RemoteAction a{}; a.type=audio_capture; a.a=!muted_; Send(a);
      } else if (op=="clipboard") {
        const auto text=v.at("text").get<std::string>();
        if(!text.empty()&&text.size()<=kMaxClipboardBytes) SendReliableDataFrame(controller_,text.data(),text.size(),kClipboardStream);
      } else if (op=="videoSettings") {
        const int q=v.at("quality"),fps=v.at("frameRate"),pref=v.at("preference");
        if(q<0||q>2||(fps!=30&&fps!=60)||pref<0||pref>2)return;
        auto bytes=mobile_controller::VideoSettingsMessage(q,fps,pref,v.at("request").get<uint32_t>());
        if(SendReliableDataFrame(controller_,bytes.data(),bytes.size(),kControlStream)!=0)
          Event({{"type","settingsFailed"},{"request",v.at("request")}},true);
      } else if (op=="sas") {
        const auto bytes=mobile_controller::SecureAttentionMessage();
        const bool ok=SendReliableDataFrame(controller_,bytes.data(),bytes.size(),kControlStream)==0;
        Event({{"type","feedback"},{"text",ok?"已发送 Ctrl+Alt+Del":"指令发送失败，请重试"}},true);
      } else if (op=="sendFile") {
        const auto path=v.at("path").get<std::string>(),name=v.at("name").get<std::string>();
        // Only disposable staged files owned by this session may be deleted by the transfer engine.
        const auto parent=std::filesystem::weakly_canonical(std::filesystem::path(path).parent_path());
        const bool staged=parent==std::filesystem::weakly_canonical(directory_+"/outgoing");
        if(!staged||!files_||!files_->Start(path,name)) {
          if (staged) { std::error_code error; std::filesystem::remove(path, error); }
          Event({{"type","file"},{"name",name},{"progress",-1},{"sending",true},{"path",""}},true);
        }
      } else if (op=="preview") {
        std::lock_guard lock(preview_mutex_);
        preview_path_=preview_directory_+"/preview-"+std::to_string(video_generation_)+"-"+std::to_string(++preview_epoch_)+".rgba";
      } else if (op=="cancelPreview") CancelPreview();
    }
  }
  void Tick() {
    const auto now=Clock::now();
    if(identity_&&!online_&&now-signal_started_>std::chrono::seconds(40)) {
      Event({{"type","error"},{"text","服务器连接超时，请检查地址和网络"}}); Stop();
    }
    if(connecting_&&now-connection_started_>std::chrono::seconds(40)) Disconnect("连接超时，请确认设备在线");
    if(!connected_)return;
    if(files_)files_->Pump();
    if(now-keyboard_sent_>std::chrono::milliseconds(200)) {
      RemoteAction a{}; a.type=keyboard_state; a.ks.seq=++keyboard_sequence_;
      for(int key:keys_) { if(a.ks.pressed_count>=kMaxKeyboardStateKeys)break; a.ks.pressed_keys[a.ks.pressed_count++]={size_t(key),0,false}; }
      Send(a,kKeyboardStream); keyboard_sent_=now;
      const auto local=std::chrono::duration_cast<std::chrono::microseconds>(now.time_since_epoch()).count();
      const auto rtc=GetSystemTimeMicros(controller_); if(rtc>0)clock_offset_=rtc-local;
    }
  }
  void Run() {
    for(;;) {
      std::function<void()> fn;
      { std::unique_lock lock(queue_mutex_); ready_.wait_for(lock,std::chrono::milliseconds(10),[this]{return stopping_||!pending_.empty();});
        if(stopping_)break; if(!pending_.empty()){fn=std::move(pending_.front());pending_.pop_front();} }
      try { if(fn)fn(); Tick(); }
      catch(const std::exception&) { Event({{"type","error"},{"text","操作失败，请检查连接参数或重新连接"}}); }
    }
    Stop();
  }
  std::mutex queue_mutex_,events_mutex_,preview_mutex_;
  uint64_t preview_epoch_ = 0;
  std::condition_variable ready_;
  std::deque<std::function<void()>> pending_;
  json events_=json::array();
  bool stopping_=false,online_=false,connecting_=false;
  std::atomic<bool> connected_{false},muted_{false},suspended_{false};
  std::atomic<uint64_t> session_{0},connection_{0},video_generation_{1},frame_id_{0};
  std::atomic<int64_t> clock_offset_{0};
  std::atomic<int> display_{0};
  PeerPtr* identity_=nullptr;
  PeerPtr* controller_=nullptr;
  std::unique_ptr<Context> identity_context_,control_context_;
  std::unique_ptr<mobile_controller::FileTransferSession> files_;
  std::string server_,logs_,login_,controller_login_,remote_,directory_,preview_directory_,preview_path_,version_;
  int port_=9099,signal_status_=-1;
  uint64_t signal_generation_=0;
  std::set<int> keys_;
  unsigned buttons_=0;
  uint32_t keyboard_sequence_=0;
  float x_=.5f,y_=.5f;
  Clock::time_point signal_started_,connection_started_,keyboard_sent_;
  AudioPlayer audio_;
  Renderer renderer_;
  std::thread worker_;
};
std::mutex mobile_mutex;
std::unique_ptr<MobileSession> mobile;
}
void MobileCommand(const std::string& text) {
  if(text.size()>1024*1024)return;
  std::lock_guard lock(mobile_mutex);
  if(!mobile)mobile=std::make_unique<MobileSession>();
  mobile->Command(text);
}
std::string MobilePoll() { std::lock_guard lock(mobile_mutex); return mobile?mobile->Poll():"[]"; }
void MobileShutdown() { std::lock_guard lock(mobile_mutex); mobile.reset(); }
}