--
-- BJR_PivotingAxle
-- Specialization for pivoting axle mod
--
-- @author      JoXXer
-- @date          01/08/13
--

BJR_PivotingAxle = {}

function BJR_PivotingAxle.prerequisitesPresent(specializations)
    return SpecializationUtil.hasSpecialization(Steerable, specializations)
end

function BJR_PivotingAxle:load(savegame)

    -- Front axle animation
    self.frontAxle = {};
    self.frontAxle.rotNode = Utils.indexToObject(self.components, getXMLString(xmlFile, "vehicle.frontAxle#rotNode"))
    
    --[[if self.frontAxle.rotNode ~= nil then
        local ax, ay, az = getTranslation(self.wheels[1].repr)
        self.frontAxle.origWheelYTrans = ay
        
        local x, y, z = getTranslation(self.frontAxle.rotNode)
        
        setTranslation(self.frontAxle.rotNode, x, ay, z);
        
        self.frontAxle.origXTrans = x
        self.frontAxle.origYTrans = ay
        self.frontAxle.origZTrans = z
    end]]
    
    --[[self.frontAxle.steeringPiston = Utils.indexToObject(self.components, getXMLString(xmlFile, "vehicle.frontAxle#steeringPiston"));

    if self.frontAxle.steeringPiston ~= nil then
        self.frontAxle.steeringMaxTrans = getXMLFloat(xmlFile, "vehicle.frontAxle#steeringMaxTrans");
        self.frontAxle.steeringMinTrans = getXMLFloat(xmlFile, "vehicle.frontAxle#steeringMinTrans");
    
        local x, y, z = getTranslation(self.frontAxle.steeringPiston);
        self.frontAxle.steeringPistonOrigY = y;
        self.frontAxle.steeringPistonOrigZ = z;
    end;]]
    
    -- Animated wheels
    self.numAnimatedWheels = Utils.getNoNil(getXMLInt(xmlFile, "vehicle.animatedWheels#count"), 0);
    --self.wheelAngle = Utils.getNoNil(getXMLInt(xmlFile, "vehicle.animatedWheels#wheelAngle"), 0);
    --self.fenderAngle = Utils.getNoNil(getXMLInt(xmlFile, "vehicle.animatedWheels#fenderAngle"), 0);
    self.animatedWheel = {};
    for i=1, self.numAnimatedWheels do
        local objname = string.format("vehicle.animatedWheels.wheel" .. "%d", i);
        self.animatedWheel[i] = {};
        self.animatedWheel[i].rotNode = Utils.indexToObject(self.components, getXMLString(xmlFile, objname .. "#rotNode"));
        --self.animatedWheel[i].wheel = Utils.indexToObject(self.components, getXMLString(xmlFile, objname .. "#wheelIndex"));
        --self.animatedWheel[i].fenderAttach = Utils.indexToObject(self.components, getXMLString(xmlFile, objname .. "#fenderAttach"));
    end;
end

function BJR_PivotingAxle:delete()end
function BJR_PivotingAxle:readStream(streamId, connection)end
function BJR_PivotingAxle:writeStream(streamId, connection)end
function BJR_PivotingAxle:readUpdateStream(streamId, timestamp, connection)end
function BJR_PivotingAxle:writeUpdateStream(streamId, connection, dirtyMask)end
function BJR_PivotingAxle:mouseEvent(posX, posY, isDown, isUp, button)end
function BJR_PivotingAxle:keyEvent(unicode, sym, modifier, isDown)end

function BJR_PivotingAxle:update(dt)
    if self:getIsActive() then
        if self.frontAxle.rotNode ~= nil and self.wheels[1].repr ~= nil and self.wheels[2].repr ~= nil then
            local ax, ay, az = getWorldTranslation(self.wheels[1].repr)
            local bx, by, bz = getWorldTranslation(self.wheels[2].repr)
            local x, y, z = worldDirectionToLocal(getParent(self.frontAxle.rotNode), bx-ax, by-ay, bz-az)
    
            setDirection(self.frontAxle.rotNode, x, y, z, 0, 0, 1)
    
            local x2,y2,z2 = getRotation(self.frontAxle.rotNode)
            
            --renderText(0.5, 0.65, 0.040, "x=" .. string.format((x2/3.14) * 180));
            --renderText(0.5, 0.75, 0.040, "y=" .. string.format((y2/3.14) * 180));
            --renderText(0.5, 0.85, 0.040, "z=" .. string.format((z2/3.14) * 180));
    
            setRotation(self.frontAxle.rotNode,x2 - math.rad(90),y2,z2 + math.rad(90))
            
            -- Front suspension
            --[[ax, ay, az = getTranslation(self.wheels[1].repr);
            bx, by, bz = getTranslation(self.wheels[2].repr);
            
            local wheel1Diff = self.frontAxle.origWheelYTrans - ay;
            local wheel2Diff = self.frontAxle.origWheelYTrans - by;
            
            local newAverageYTrans = (wheel1Diff - wheel2Diff)/2;
            
            setTranslation(self.frontAxle.rotNode, self.frontAxle.origXTrans, (self.frontAxle.origYTrans + newAverageYTrans), self.frontAxle.origZTrans);]]
        end
    
        -- Making the visible wheels rotate
        if self.wheels[1].repr ~= nil and self.wheels[2].repr ~= nil then
            --local x,y,z = getRotation(self.wheels[1].driveNode);
            local x2,y2,z2 = getRotation(self.wheels[1].repr);
            --setRotation(self.animatedWheel[1].wheel, x,y,z);
            setRotation(self.animatedWheel[1].rotNode, x2,y2,z2);
    
            --local x3,y3,z3 = getRotation(self.wheels[2].driveNode);
            local x4,y4,z4 = getRotation(self.wheels[2].repr);
            --setRotation(self.animatedWheel[2].wheel, x3,y3,z3);
            setRotation(self.animatedWheel[2].rotNode, x4,y4,z4);
            
            --[[if self.frontAxle.steeringPiston ~= nil then
                local newSteeringXTrans = 0;
                
                if y2 < 0 then
                    newSteeringXTrans = (self.frontAxle.steeringMinTrans/self.wheels[1].rotMin) * y2;
                elseif y2 > 0 then
                    newSteeringXTrans = (self.frontAxle.steeringMaxTrans/self.wheels[1].rotMax) * y2;
                end;
                
                setTranslation(self.frontAxle.steeringPiston, -newSteeringXTrans, self.frontAxle.steeringPistonOrigY, self.frontAxle.steeringPistonOrigZ);
            end;]]
        end;
    
        -- Dynamic fenders
        --[[if self.animatedWheel[1].fenderAttach ~= nil and self.animatedWheel[2].fenderAttach ~= nil then
            local x, y, z = getRotation(self.animatedWheel[1].rotNode);
            local x2, y2, z2 = getRotation(self.animatedWheel[2].rotNode);
    
            local fenderYRot = -y + math.rad(self.fenderAngle);
            local fenderY2Rot = -y2 + math.rad(-self.fenderAngle);
    
            if y > math.rad(self.fenderAngle) then
                setRotation(self.animatedWheel[1].fenderAttach, x, fenderYRot, z);
            else
                setRotation(self.animatedWheel[1].fenderAttach, x, 0, z);
            end;
            
            if y2 < math.rad(-self.fenderAngle) then
                setRotation(self.animatedWheel[2].fenderAttach, x2, fenderY2Rot, z2);
            else
                setRotation(self.animatedWheel[2].fenderAttach, x2, 0, z2);
            end;
    
            --local x3,y3,z3 = getRotation(self.animatedWheel[1].fenderAttach);
            --renderText(0.5, 0.65, 0.040, string.format(y3));
    
            --local x4,y4,z4 = getRotation(self.animatedWheel[2].fenderAttach);
            --renderText(0.5, 0.55, 0.040, string.format(y4));
        end;]]
        
        
        -- abgled wheels 
        --[[if self.animatedWheel[1].rotNode ~= nil and self.animatedWheel[2].rotNode ~= nil then
            local x, y, z = getRotation(self.animatedWheel[1].rotNode);
            local x2, y2, z2 = getRotation(self.animatedWheel[2].rotNode);
            
            local nodeZRot = -y + math.rad(self.wheelAngle);
            local nodeZ2Rot = -y2 + math.rad(-self.wheelAngle);
            
            if y > math.rad(self.wheelAngle) then
                setRotation(self.animatedWheel[1].rotNode, x, y, nodeZRot);
                setRotation(self.animatedWheel[2].rotNode, x2, y2, nodeZRot);
            elseif y < math.rad(-self.wheelAngle) then
                setRotation(self.animatedWheel[1].rotNode, x, y, nodeZ2Rot);
                setRotation(self.animatedWheel[2].rotNode, x2, y2, nodeZ2Rot);
            else
                setRotation(self.animatedWheel[1].rotNode, x, y, 0);
                setRotation(self.animatedWheel[2].rotNode, x2, y2, 0);
            end;
            
            --local x3,y3,z3 = getRotation(self.animatedWheel[1].fenderAttach);
            --renderText(0.5, 0.65, 0.040, string.format(y3));
    
            --local x4,y4,z4 = getRotation(self.animatedWheel[2].fenderAttach);
            --renderText(0.5, 0.55, 0.040, string.format(y4));
        end;]]
    end
end

function BJR_PivotingAxle:updateTick(dt)end
function BJR_PivotingAxle:draw()end