using System.Collections.Generic;
using UnityEngine;

public class Player : MonoBehaviour {

    //プレイヤーが操作しているか
    [SerializeField] bool isPlayerOperation = false;

    //コンポーネント****************************************
    Team team;
	PlayerPassAction playerPass;
    PlayerShootAction playerShoot;
	PlayerAnimation animation;
    Ball ballScript;
	FlagManager flag;
	GameManager gmanager;
	TouchJudgeSprite touchJudge;
	Rigidbody rig;
    //******************************************************

    //移動関連**********************************************
    List<Vector3> movePos = new List<Vector3>();//ドラッグした軌跡の各ポジション
	bool isPlayerMoveDoing = false;             //プレイヤーを操作中か(動作しているか)
    bool isOperating = false;   //操作されているか(移動用)
    public float playerMoveSpeed = 0.6f;
    //******************************************************

    //steelオブジェクト
    GameObject steel;

    //ボール操作関連****************************************
    //ボールを持っているか
    public bool have_ball = false;
    //ドリブルの際の手の位置
    [SerializeField] GameObject myHandPos_Obj;
    //パスやシュートをするときのボール格納
    [SerializeField] GameObject ballObj;
	//パスの時のボールが出る場所
	[SerializeField] Transform passTrans;
	//パスの時のボールが出る場所
	[SerializeField] Transform shootTrans;
    [SerializeField] float ballSpeed;
    //パスしたボールの速さ
    private float passSpeed = 1000;
    //ボールを離した後、当たり判定を一定時間行わせないためのフレームカウント
    int ballSeparateCount = 0;
    //******************************************************

    //シュート関連*******************************************
    bool isShootOK = false;		//シュート許可
    //Goal Postオブジェクト格納用
    public GameObject[] goalpost = new GameObject[2];
	//狙うゴール(整数で決める)　0=Goal Post0, 1=Goal Post1
	public int targetGoalNum = 0;
	//狙う正確な座標　（ゴールネットの上 0=x座標 -14.5f, 1=y座標 16f）
	public float[] targetPos = new float[2];
    //******************************************************

    //スローインをしたかどうかの判定
    public bool throwOK;


	/// <summary>
    /// キャラクターのアニメーションなどの効果音
    /// </summary>
    //コンポーネント
	CharacterSE charase;
		
	public bool dash = false;
    public float movement = 0;
    //public bool PlayerControl = false;

    //移動目的地の座標
    public Vector3 movepoint;

    //リアルタイムの移動速度
    public float nowspeed = 0f;

    //初期設定
    void Start () {

        //コンポーネントを取得する
        flag = GameObject.Find("Manager").GetComponent<FlagManager>();
        gmanager = GameObject.Find("Manager").GetComponent<GameManager>();
        team = GetComponent<Team>();
		charase = GetComponent<CharacterSE>();
		animation = GetComponent<PlayerAnimation>();
		playerPass = GetComponent<PlayerPassAction>();
        playerShoot = GetComponent<PlayerShootAction>();
        ballScript = GameObject.Find("ball").GetComponent<Ball>();
		rig = GetComponent<Rigidbody>();

        //オブジェクト名でゴールを取得
        goalpost[0] = GameObject.Find("Goal Post0").gameObject;
		goalpost[1] = GameObject.Find("Goal Post1").gameObject;
        //ボールを奪う当たり判定
		steel = transform.FindChild("steel").gameObject;

		targetGoalNum = team.teamNum;
        throwOK = false;
    }

	// Update is called once per frame
	void Update () {
        if (!gmanager.IsGamePlayOK()) return;
        mainAction();
    }

    //=========================================================
    //毎フレーム行う処理
    //=========================================================
    void mainAction()
    {
        if (movePos.Count > 0) playerMoveToList();

		//ボールを持っていればドリブル
		haveBallAndDrible();
		//Rigidbodyのリセット
		rigidbodyReset();

        //シュートの処理
        //毎フレーム処理が必要なため、ここで検証
        ShootJudgeAndShoot();
        //シュート時のアニメーション
        ShootAnimation();

        //移動量が減った時
        if (dash && movement < 0.3f)
        {
            dash = false;
            //シューズ音を鳴らす
            charase.PlayCharaSE(0);
        }
    }

	//=========================================================
	//ボール所持の判定でドリブルを行う
	//=========================================================
	void haveBallAndDrible(){
		if (have_ball)
		{
			if (!animation.isAddFrame())//シュート中にドリブルしてしまうため、判定を追加
				ballScript.dribble(myHandPos_Obj.transform.position, 40);
		}
		else if (ballSeparateCount <= 10)
		{
			ballSeparateCount++;//ボールを離した瞬間0になるので加算
		}
	}
	//=========================================================
	//Rigidbodyの状態をON、力のリセットを行う
	//=========================================================
	void rigidbodyReset(){
		rig.WakeUp();
		//相手に押された時の力をリセット
		rig.velocity = Vector3.zero;
	}
    //=========================================================
    //シュートの許可を判断してシュートを行う
    //=========================================================
    void ShootJudgeAndShoot()
    {
        if (isShootOK)
        {
            if (isPlayerOperation)
                Shooting();//プレイヤーが操作している
            else
                //プレイヤーが操作していないときは別の関数を用意する
                CPUShooting();
        }
    }
    //=========================================================
    //移動しない状態　
    //=========================================================
    public void Standby()
    {
		//moveアニメーションを止める
		animation.Standby();
	}

	//=========================================================
	//リストに移動先を追加(タッチ機能のスクリプトから格納される)
	//=========================================================
	public void movePosAdd(Vector3 addPos)
	{
		movePos.Add(addPos);
		//Debug.Log("移動先格納" + addPos);
	}

	//=========================================================
	//プレイヤーを動かす処理を呼び出す
	//=========================================================
	void playerMoveToList()
	{
		if (isPlayerMoveDoing) return;
		if (movePos.Count <= 0) return;
		//リストに格納されている分だけ実行する
		playerMove(movePos[0]);
		movePos.RemoveAt(0);
		isPlayerMoveDoing = true;
	}

	//=========================================================
	//プレイヤーの移動関連
	//=========================================================
	void playerMove(Vector3 moveTargetPos)
	{
		//操作するプレイヤーを取得
		PlayerMove playerMove = GetComponent<PlayerMove>();

		StartCoroutine(playerMove.Move(moveTargetPos));
	}

	//PlayerMoveから、移動する処理が終了したら判定を変更される
	public void isPlayerMoveDoingFalse()
	{
		isPlayerMoveDoing = false;
	}

	//ダッシュのスピード書き換え
	public void rewriteMoveSpeed()
	{
		//Debug.Log("RewiteMoveSpeed");
		GetComponent<PlayerMove>().rewriteMoveSpeed(0.5f);
	}

	//移動 (方向、速さ、制限をかけるかどうか）
	public void CPUMove(float angle, float j_distance)
    {
        //シュート中などのアニメーションしてるときは動けない
        if (!animation.isShootAnim() && !throwOK)
        {
            movement = j_distance;

            if (movement >= 0.9f && !dash)
            {
                dash = true;
            }

            //moveアニメーションさせる
            animation.animSetFloat("move", j_distance);

            //angleからプレイヤーの向きを変更
            transform.rotation = Quaternion.Euler(0, angle, 0);

            //プレイヤーが向いている方向に移動
            transform.Translate(Vector3.forward * playerMoveSpeed * j_distance);
        }
    }

    //
    void addSpeed()
    {
        //1になるまで加算する
        if (nowspeed < 1f)
        {
            nowspeed += Time.deltaTime;
        }
        else if (nowspeed > 1f)
        {
            nowspeed = 1f;
        }
    }

    //
    float moveAngle()
    {
        float angle = 0;        //求める角度格納用 0で初期化

        //自分と目的地の角度
        angle = Vector3.Angle(new Vector3(movepoint.x, transform.position.y, movepoint.z), transform.position);

        return angle;
    }


    //=========================================================
    //ボール関連
    //=========================================================
    /// <summary>
    /// </summary>
    /// <param パスしたキャラクター ="objchara"></param>
    //パスされたボールをキャッチする
    public void Catch(GameObject objchara)
    {
        //パスしてくれたキャラクターの方を向く
        transform.LookAt(objchara.transform);

        //キャッチのアニメーションをさせる
       animation.animatorTrigger("catch");
    }    

    //タッチ機能から呼び出される
    public void Pass()
    {
		//ボールを持った状態ならパスをする　シュート中はパスできないようにする
		if (have_ball && !animation.isShootAnim())
		{
			GameObject passTarget = serchChara();

            //ボールを持っている状態のアニメーションを止める
            animation.animatorBool("ball_have", false);

            //パスのアニメーションをさせる
            animation.animatorTrigger("pass");

			//カメラの追従を止めるため
			gmanager.ballChara = null;
			GameObject.Find("Main Camera").gameObject.GetComponent<ControlCamera>().charBall = null;

			//仲間のほうを向く
			transform.LookAt(passTarget.transform);

			ballObj.transform.parent = null;
			ballObj.transform.position = passTrans.position;

			Vector3 force;
			force = this.transform.forward * passSpeed;
			ballObj.GetComponent<SphereCollider>().enabled = true;//コライダー有効

			//ボールの物理とコライダーを有効にし、飛ばしたのちに初期化
			ballObj.GetComponent<Rigidbody>().isKinematic = false;

			ballObj.GetComponent<Rigidbody>().AddForce(force, ForceMode.Impulse);
			
			BallThrowAfter();
			
			//パスを受け取ったキャラクターにアニメーションさせるため
			passTarget.GetComponent<Player>().Catch(gameObject);
		}
		//playerPass.Pass();
	}

    public void roopPass(Vector3 targetPos)
    {
        {
            if (have_ball && !animation.isShootAnim())
            {
                Rigidbody rig = ballObj.GetComponent<Rigidbody>();
                //////////////////////////////////////////////////////
                //パスのアニメーションをさせる
                animation.animatorTrigger("pass");
                //仲間のほうを向く
                transform.LookAt(targetPos);
                //ボールを持っている状態のアニメーションを止める
                animation.animatorBool("ball_have", false);

                ballObj.transform.parent = null;

                ballObj.transform.position = passTrans.position;

                ////////////////////////////////////////////////////////
                //計算

                //ゴールまでのベクトル(方向)
                Vector3 vec_ThrowAngle = new Vector3().BallThrowAngleVec(passTrans.position, targetPos, rig, 0.5f);

                rig.isKinematic = false;

                rig.useGravity = true;

                ballObj.GetComponent<SphereCollider>().enabled = true;//コライダー有効

                rig.angularVelocity = new Vector3(-2, 5, 0);//ボールの回転

                rig.AddForce(vec_ThrowAngle, ForceMode.Impulse);//力を掛けてボールを飛ばす


                BallThrowAfter();
            }
        }
    }

        //==========================================================================================
        //ボールを投げた後の処理
        //==========================================================================================
        protected void BallThrowAfter()
    {
        have_ball = false;
        ballSeparateCount = 0;
    }

    //==========================================================================================
    //シュート関連
    //==========================================================================================
    //ボールを投げてシュートする
    void BallThrowShoot(Vector3 targetPos)
    {
        //Debug.Log("Goal = " + targetPos);
        Rigidbody rig = ballObj.GetComponent<Rigidbody>();

        //計算
        //ゴールまでの距離  ↓使ってなくね？
        //float distance = Vector3.Distance(transform.position, new Vector3(targetPos.x, transform.position.y, targetPos.z));
        //ゴールまでのベクトル(方向)：：拡張機能使用
        Vector3 vec_ThrowAngle = new Vector3().BallThrowAngleVec(shootTrans.position, targetPos, rig);

		//================================================================================================
		//投げる
		//================================================================================================
		ballObj.transform.position = shootTrans.position;//念のためもう一度ボールの位置を調整する
		rig.isKinematic = false;
		rig.useGravity = true;
       //ballObj.GetComponent<Ball>().shootTrue();
        rig.AddForce(vec_ThrowAngle, ForceMode.Impulse);//力を掛けてボールを飛ばす

		BallThrowAfter();
    }

    //呼び出される
    public void Shoot()
    {
		if (have_ball && !animation.isShootAnim() && !throwOK)
		{
			//Debug.Log("Shoot、if判定クリア");
			//ゴールポストの方へ向く
			transform.LookAt(new Vector3(goalpost[targetGoalNum].transform.position.x + targetPos[0], transform.position.y, goalpost[targetGoalNum].transform.position.z));

			///===================================================================================================================================================
			/// <summary>
			/// 8/31 以下のものをコピペして　by三井
			/// </summary>

			//カメラを接近させる
			GameObject.Find("Main Camera").GetComponent<ControlCamera>().cameraType = 1;

			//以下のものは消していい　by三井
			//GameObject.Find("Main Camera").GetComponent<ControlCamera>().setBallShootAction(true);

			//GameObject.Find("Main Camera").GetComponent<CameraAction>().zoomInCamera();
			///===================================================================================================================================================

			//flameの加算を始めるため
			animation.setAddFlame(true);
			animation.setShootAnm(true);
            flag.buzzerBeater = true;

            //シュートのアニメーションをさせる
            animation.animatorTrigger("shoot");

			//ボールを持っている状態のアニメーションを止める
			animation.animatorBool("ball_have", false);
		}
	}

    //PlayerAnimationのシュート時のアニメーションから呼び出される、ボールの位置合わせ
    public void ballPosAlignment()
    {
        ballObj.transform.position = shootTrans.position;
    }

    //シュート処理
    void Shooting()
    {
        if (!isShootOK) return;

        //playerShoot.GaugeJudge();//ゲージの計算
        //ゴールの位置
        Vector3 goalTargetPos = goalpost[targetGoalNum].transform.FindChild("GoalTargetPoint").gameObject.transform.position;
		//Debug.Log("ゴールのポジション = " + goalTargetPos);
		//シュート成功判定がfalseなら、ゲージで算出したずれを加算する
        //if (!playerShoot.getShootSuccess())
        //{
            //goalTargetPos += playerShoot.getShootEndPoint();
            //Debug.Log("シュート失敗判定のため、ずらす" + playerShoot.getShootEndPoint());
        //}

		//flag.shootsuccess = true;
		//リプレイ用（まだ使えない）
		//GameObject.Find("Manager").GetComponent<ReplayManagerGUI>().mode = 0;

		//ボールの位置を調整する
		ballObj.transform.parent = null;
		ballObj.transform.position = shootTrans.position;
        ballObj.GetComponent<SphereCollider>().enabled = true;//コライダー有効

        //ボールの物理とコライダーを有効にし、飛ばしたのちに初期化
        ballObj.GetComponent<Rigidbody>().isKinematic = false;

        //投げる処理
        BallThrowShoot(goalTargetPos);

        ballObj = null;
        isShootOK = false;
        //jstartf = false;
        flag.buzzerBeater = false;
        BallThrowAfter();
    }

    //シュートアニメーション時にジャンプさせる
    public void ShootAnimation()
    {
        animation.jumpJudge();
	}
    public void setShootOK(bool b)
    {
        isShootOK = b;
    }

    //ダッシュと通常移動のスピード切り替え
    public void rewriteSpeed(float re_speed)
    {
        playerMoveSpeed = re_speed;
    }

    public void Block()
    {
        //ここ↓
        //一番近い相手のほうを向く

        //ボールを持っている相手のほうを向く
        transform.LookAt(gmanager.ballChara.transform);

        steel.GetComponent<BoxCollider>().enabled = true;
    }
    public void blockRelease()
    {
        steel.GetComponent<BoxCollider>().enabled = false;
    }

    //==========================================================================================
    //キャラクターがボールを持つ
    //==========================================================================================
    public void BallGet()
    {
        ballScript = ballObj.GetComponent<Ball>();

        //ボールの物理、コライダーを無効化する
        ballObj.GetComponent<Rigidbody>().isKinematic = true;
        ballObj.GetComponent<SphereCollider>().enabled = false;//コライダー無効化

        have_ball = true;

        //ボールを子要素にし、位置と向きを調整
        ballObj.transform.parent = this.transform;
        ballObj.transform.position = myHandPos_Obj.transform.position;
        ballObj.transform.rotation = Quaternion.Euler(0, 0, 0);

        //複数のプレイヤーがボールを所持しないようにする
        ballObj.GetComponent<Ball>().HaveBallPlayerOrgange();

        //ボールを持っている状態のアニメーションをさせる
        animation.animatorBool("ball_have", true);

        //カメラに追従してもらうため、このオブジェクトを登録する
        ControlCamera cam = GameObject.Find("Main Camera").gameObject.GetComponent<ControlCamera>();
        cam.charBall = gameObject;
        //カメラが通常時でないときにカメラを通常モードに戻す
        if(cam.cameraType != 0)
        {
            cam.cameraType = 0;
        }

        //FlagManagerにチームボールの判定をさせる
        GameObject.Find("Manager").GetComponent<GameManager>().ballChara = gameObject;
        GameObject.Find("Manager").GetComponent<FlagManager>().BallChenge(team.teamNum);
        GameObject.Find("Manager").GetComponent<Score>().BallChar = gameObject;

        //スローインからのパスの時
        if (gmanager.throwinChara != null && gmanager.throwinChara.GetComponent<Player>().throwOK)
        {
            gmanager.throwinChara.GetComponent<Player>().throwOK = false;
            flag.fieldGoal = false;
            gmanager.throwinChara = null;
        }
    }

    //あたり判定
    private void OnCollisionEnter(Collision collision)
    {
        if (have_ball || ballSeparateCount <= 10) return;

        //レイヤー名取得
        string layerName = LayerMask.LayerToName(collision.gameObject.layer);
        //レイヤー名がボールであればボールを消してボールを持っている状態にする
        if (layerName == "ball")
        {
            ballObj = collision.gameObject;
            BallGet();
        }
	}
    //=========================================================
    //一定時間ブロックされてボールを取られた、PlayerActionSteelから呼び出される
    //=========================================================
    public void steeler()
	{
		Vector3 force;
		force = this.transform.forward * passSpeed;
        Collideroff();
        //すでにボールを奪われた時はスティールをしない
        if (!have_ball) return;
		ballObj.transform.position = passTrans.position;
        ballObj.GetComponent<SphereCollider>().enabled = true;//コライダー有効
        //ボールの物理とコライダーを有効にし、飛ばしたのちに初期化
        ballObj.GetComponent<Rigidbody>().isKinematic = false;
        ballObj.GetComponent<Rigidbody>().AddForce(force / 5f, ForceMode.Impulse);//弱く投げる(はじかれた時の再現のつもり)
        ballObj.transform.parent = null;
        have_ball = false;
		//ボールを持っている状態のアニメーションを止める
		animation.animatorBool("ball_have", false);
		GameObject.Find("Main Camera").gameObject.GetComponent<ControlCamera>().charBall = null;
	}
    
	//あたり判定をなくす
	private void Collideroff()
	{
		GetComponent<BoxCollider>().enabled = false;
		//処理遅延
		Invoke("Collideron", 1);
	}

	//あたり判定をもどす
	private void Collideron()
	{
		GetComponent<BoxCollider>().enabled = true;
	}

    //=========================================================
    //味方チームのキャラクターで最も近いものを取得
    //=========================================================
    public GameObject serchChara()
    {
        float tmpDis = 0;                           //距離用一時変数
        float nearDis = 0;                          //最も近いオブジェクトの距離
        int myteam = team.teamNum;          //自分のチーム
        int mynum = team.memberNum;       //自分の（メンバー）ナンバー

        GameObject targetObj = null; //オブジェクト

        for (int num = 0; num < 5 && gmanager.teamList[myteam].member[num] != null; num++)
        {
            if (gmanager.teamList[myteam].member[num] != gameObject)
            {
                //自身と取得したオブジェクトの距離を取得
                tmpDis = Vector3.Distance(gmanager.teamList[myteam].member[num].transform.position, gameObject.transform.position);

                //オブジェクトの距離が近いか、距離0であればオブジェクト名を取得
                //一時変数に距離を格納
                if (nearDis == 0 || nearDis > tmpDis)
                {
                    nearDis = tmpDis;
                    targetObj = gmanager.teamList[myteam].member[num];
                }
            }
        }
        //最も近かったオブジェクトを返す
        return targetObj;   
    }

    void CPUShooting()
    {
        if (!isShootOK) return;

        //ゴールの位置
        Vector3 goalTargetPos = goalpost[targetGoalNum].transform.FindChild("GoalTargetPoint").gameObject.transform.position;

        //ボールの位置を調整する
        ballObj.transform.position = shootTrans.position;
        ballObj.GetComponent<SphereCollider>().enabled = true;//コライダー有効

        //ボールの物理とコライダーを有効にし、飛ばしたのちに初期化
        ballObj.GetComponent<Rigidbody>().isKinematic = false;

        //投げる処理
        BallThrowShoot(goalTargetPos);

        ballObj.transform.parent = null;
        ballObj = null;
        isShootOK = false;
        //jstartf = false;
        flag.buzzerBeater = false;
        BallThrowAfter();
    }
    //=========================================================
    //PlayerShootActionへ現在狙っているゴールのポジションを返す
    //=========================================================
    public Vector3 getAimGoalPostPosition()
    {
        return goalpost[targetGoalNum].transform.FindChild("GoalTargetPoint").gameObject.transform.position;
    }
    public bool isHaveBall()
    {
        return have_ball;
    }
    //=========================================================
    //GameManagerから呼び出される。複数人のボール所持をなくす
    //=========================================================
    public void setHaveBall(bool b)
    {
        have_ball = b;
    }


	public void removeMovePosListZero()
	{
		movePos.RemoveAt(0);
	}
	public void moveColBreak()
	{
		StopCoroutine(GetComponent<PlayerMove>().Move(Vector3.zero));
		movePos.Clear();
	}
	public void IsOperatingChange(bool b)
	{
		isOperating = b;
	}

	public bool IsOperating()
	{
		return isOperating;
	}

	public bool IsPlayerOperating()
	{
		return isPlayerOperation;
	}
	public int getMovePosListCount()
	{
		return movePos.Count;
	}
}