using System.Collections;
using System.Collections.Generic;
using System.Linq;
using UnityEngine;
using UnityEngine.XR;
using Photon.Pun;
using Unity.XR.CoreUtils;
using UnityEngine.InputSystem.XR;
using RootMotion.Demos;
using RootMotion.FinalIK;
using UnityEngine.XR.Interaction.Toolkit;

public class NetworkPlayer : MonoBehaviourPun, IPunObservable, IPunInstantiateMagicCallback
{
    public VRIK ik;
    public Transform Head;
    public Transform LeftHand;
    public Transform RightHand;

    private PhotonView PhotonView;

    private Transform HeadRig;
    private Transform LeftHandRig;
    private Transform RightHandRig;

    private NetworkTransform rootNetworkT = new NetworkTransform();
    private NetworkTransform headNetworkT = new NetworkTransform();
    private NetworkTransform leftHandNetworkT = new NetworkTransform();
    private NetworkTransform rightHandNetworkT = new NetworkTransform();
    [Tooltip("The speed of interpolating remote IK targets.")] public float proxyInterpolationSpeed = 20f;
    [Tooltip("Max interpolation error square magnitude. IK targets snap to latest synced position if current interpolated position is farther than that.")] public float proxyMaxErrorSqrMag = 4f;
    // Start is called before the first frame update
    void Start()
    {
        PhotonView = GetComponent<PhotonView>();
        XROrigin rig = FindObjectOfType<XROrigin>();

        HeadRig = rig.transform.Find("Camera Offset/Main Camera");
        LeftHandRig = rig.transform.Find("Camera Offset/LeftHand Controller");
        RightHandRig = rig.transform.Find("Camera Offset/RightHand Controller");

        if (PhotonView.IsMine)
        {
            foreach (var item in GetComponentsInChildren<Renderer>())
            {
                //item.enabled = false;
            }
        }
    }

    // Update is called once per frame
    void Update()
    {
        if(PhotonView.IsMine)
        {
            MapPosition(Head, HeadRig);
            MapPosition(LeftHand, LeftHandRig);
            MapPosition(RightHand, RightHandRig);
            // Update IK target velocities (for interpolation)
            rootNetworkT.ReadVelocitiesLocal(ik.references.root);
            headNetworkT.ReadVelocitiesLocal(ik.solver.spine.headTarget);
            leftHandNetworkT.ReadVelocitiesLocal(ik.solver.leftArm.target);
            rightHandNetworkT.ReadVelocitiesLocal(ik.solver.rightArm.target);

            // Update IK target positions/rotations
            rootNetworkT.ReadTransformLocal(ik.references.root);
            headNetworkT.ReadTransformLocal(ik.solver.spine.headTarget);
            leftHandNetworkT.ReadTransformLocal(ik.solver.leftArm.target);
            rightHandNetworkT.ReadTransformLocal(ik.solver.rightArm.target);
        }

        headNetworkT.ApplyRemoteInterpolated(Head, proxyInterpolationSpeed, proxyMaxErrorSqrMag);
        leftHandNetworkT.ApplyRemoteInterpolated(LeftHand, proxyInterpolationSpeed, proxyMaxErrorSqrMag);
        rightHandNetworkT.ApplyRemoteInterpolated(RightHand, proxyInterpolationSpeed, proxyMaxErrorSqrMag);
    }

    void MapPosition(Transform target,Transform rigTransform)
    {
        target.position = rigTransform.position;
        target.rotation = rigTransform.rotation;
    }
    public void OnPhotonSerializeView(PhotonStream stream, PhotonMessageInfo info)
    {
        if (stream.IsWriting)
        {
            // Send NetworkTransform data
            rootNetworkT.Send(stream);
            headNetworkT.Send(stream);
            leftHandNetworkT.Send(stream);
            rightHandNetworkT.Send(stream);
        }
        else
        {
            // Receive NetworkTransform data
            rootNetworkT.Receive(stream);
            headNetworkT.Receive(stream);
            leftHandNetworkT.Receive(stream);
            rightHandNetworkT.Receive(stream);
        }
    }

    public void OnPhotonInstantiate(PhotonMessageInfo info)
    {

    }
}