#
# BSD 3-Clause License
#
# Copyright (c) 2022 University of Wisconsin - Madison
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are met:
#
# * Redistributions of source code must retain the above copyright notice, this
#   list of conditions and the following disclaimer.
#
# * Redistributions in binary form must reproduce the above copyright notice,
#   this list of conditions and the following disclaimer in the documentation
#   and/or other materials provided with the distribution.
#
# * Neither the name of the copyright holder nor the names of its
#   contributors may be used to endorse or promote products derived from
#   this software without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.#

#// =============================================================================
#// Author: Harry Zhang
#// =============================================================================

import osqp
import numpy as np
import scipy as sp
from scipy import sparse
import time

def mpc_wpts_solver(e,u,vel,vel_ref):
    """This function is the mpc solver for error based tracking problem
        Use: [throttle, steering] = mpc_wpts_solver(error state, current control input, current velocity of the vehicle, reference velocity)
    """
    x0 = np.array(e)
    u0 = np.array(u)

    # parameters related to the vehicle dynamics
    r_wheel = 0.08451952624
    i_wheel = 1e-3
    gamma = 1/3
    tau_0 = 0.09
    omega_0 = 161.185
    c1 = 1e-4
    l_car = 0.5
    nsim = 1
    delta_t = 0.1
    start_time = time.time()
    for i in range(nsim):

        #time dependent variables in Ad and Bd matrices
        alpha = u0[0]
        delta = u0[1] * 0.6
        e1 = x0[0]
        e2 = x0[1]
        e3 = x0[2]
        #reference/target point
        xr = np.array([0, 0, 0.,0])

            # Discrete time model of a vehicle
        Ad = sparse.csc_matrix([
            [1.0,   vel*np.tan(delta)/l_car*delta_t,  -vel_ref*np.sin(e3)*delta_t,  0.],
            [-vel*np.tan(delta)/l_car*delta_t,   1.0,  vel_ref*np.cos(e3)*delta_t,  0.],
            [0.,   0.,  1.0,  0],
            [0.,   0.,  0.,  1.0-(c1*omega_0+tau_0/(i_wheel*omega_0))*delta_t],
        ])
        #Ad = Ad * delta_t + sparse.eye(4)

        Bd = sparse.csc_matrix([
                [0.,  vel*e2/(l_car*np.cos(delta)*np.cos(delta))*delta_t],
                [0.,  -vel*e1/(l_car*np.cos(delta)*np.cos(delta))*delta_t],
                [0.,  -vel/(l_car*np.cos(delta)*np.cos(delta))*delta_t],
                [-gamma*r_wheel*tau_0/i_wheel*delta_t,  0]
                ])

        [nx, nu] = Bd.shape

        # Constraints
        #u0 = 10.5916
        umin = np.array([0.0,-0.6]) 
        umax = np.array([1, 0.6]) 
        xmin = np.array([-np.inf,-np.inf,-np.inf,-np.inf])
        xmax = np.array([np.inf, np.inf, np.inf,np.inf])
        # xmin = np.array([-0.75,-0.75,-np.inf,-np.inf])
        # xmax = np.array([0.75, 0.75, np.inf,np.inf])
        # Objective function
        Q = sparse.diags([0.0, 5500., 3500., 300.])
        QN = Q
        R = sparse.diags([10., 1000.])



        # Prediction horizon
        N = 5

        # Cast MPC problem to a QP: x = (x(0),x(1),...,x(N),u(0),...,u(N-1))
        # - quadratic objective
        P = sparse.block_diag([sparse.kron(sparse.eye(N), Q), QN,
                            sparse.kron(sparse.eye(N), R)], format='csc')
        # - linear objective
        q = np.hstack([np.kron(np.ones(N), -Q.dot(xr)), -QN.dot(xr),
                    np.zeros(N*nu)])
        # - linear dynamics
        Ax = sparse.kron(sparse.eye(N+1),-sparse.eye(nx)) + sparse.kron(sparse.eye(N+1, k=-1), Ad)
        Bu = sparse.kron(sparse.vstack([sparse.csc_matrix((1, N)), sparse.eye(N)]), Bd)
        Aeq = sparse.hstack([Ax, Bu])
        leq = np.hstack([-x0, np.zeros(N*nx)])
        ueq = leq
        # - input and state constraints
        Aineq = sparse.eye((N+1)*nx + N*nu)
        lineq = np.hstack([np.kron(np.ones(N+1), xmin), np.kron(np.ones(N), umin)])
        uineq = np.hstack([np.kron(np.ones(N+1), xmax), np.kron(np.ones(N), umax)])
        # - OSQP constraints
        A = sparse.vstack([Aeq, Aineq], format='csc')
        l = np.hstack([leq, lineq])
        u = np.hstack([ueq, uineq])

        # Create an OSQP object
        prob = osqp.OSQP()

        # Setup workspace
        prob.setup(P, q, A, l, u, warm_start=True,max_iter=10000)

        # Simulate in closed loop


            # Solve
        res = prob.solve()

            # Check solver status
        if res.info.status != 'solved':
            raise ValueError('OSQP did not solve the problem!')

            # Apply first control input to the plant
        ctrl = res.x[-N*nu:-(N-1)*nu]
        u0 = ctrl
        x0 = Ad.dot(x0) + Bd.dot(ctrl)

            # Update initial state
        l[:nx] = -x0
        u[:nx] = -x0
        prob.update(l=l, u=u)
    
    # print('For the error state: e=',e )
    # print('Control input:',ctrl)
    
    #print('Next predict state',x0)
        #print(res.x)
    #print("--- %s seconds ---" % (time.time() - start_time))
    return ctrl