server.js

const express = require('express');
const axios = require('axios');
const querystring = require('querystring');
const cookieParser = require('cookie-parser');

const app = express();
app.use(cookieParser());
app.use(express.json());
app.use(express.static('public'));

const PORT = process.env.PORT || 8080;
const SPOTIFY_CLIENT_ID = process.env.SPOTIFY_CLIENT_ID;
const SPOTIFY_CLIENT_SECRET = process.env.SPOTIFY_CLIENT_SECRET;
const LINKEDIN_CLIENT_ID = process.env.LINKEDIN_CLIENT_ID;
const LINKEDIN_CLIENT_SECRET = process.env.LINKEDIN_CLIENT_SECRET;
const REDIRECT_URI = process.env.REDIRECT_URI || 'http://localhost:8080/callback';
const LINKEDIN_REDIRECT_URI = process.env.LINKEDIN_REDIRECT_URI || 'http://localhost:8080/linkedin/callback';

// Store tokens (in production, use a database)
let tokens = {
  spotify: null,
  linkedin: null
};

// Spotify Authorization
app.get('/login', (req, res) => {
  const scope = 'user-read-currently-playing user-read-playback-state';
  res.redirect('https://accounts.spotify.com/authorize?' +
    querystring.stringify({
      response_type: 'code',
      client_id: SPOTIFY_CLIENT_ID,
      scope: scope,
      redirect_uri: REDIRECT_URI
    }));
});

// Spotify Callback
app.get('/callback', async (req, res) => {
  const code = req.query.code || null;
  
  try {
    const response = await axios.post('https://accounts.spotify.com/api/token',
      querystring.stringify({
        code: code,
        redirect_uri: REDIRECT_URI,
        grant_type: 'authorization_code'
      }), {
        headers: {
          'Authorization': 'Basic ' + Buffer.from(SPOTIFY_CLIENT_ID + ':' + SPOTIFY_CLIENT_SECRET).toString('base64'),
          'Content-Type': 'application/x-www-form-urlencoded'
        }
      });
    
    tokens.spotify = {
      access_token: response.data.access_token,
      refresh_token: response.data.refresh_token,
      expires_at: Date.now() + (response.data.expires_in * 1000)
    };
    
    res.redirect('/?spotify=connected');
  } catch (error) {
    console.error('Spotify auth error:', error.response?.data || error.message);
    res.redirect('/?error=spotify_auth_failed');
  }
});

// LinkedIn Authorization
app.get('/linkedin/login', (req, res) => {
  const scope = 'w_member_social profile';
  res.redirect('https://www.linkedin.com/oauth/v2/authorization?' +
    querystring.stringify({
      response_type: 'code',
      client_id: LINKEDIN_CLIENT_ID,
      redirect_uri: LINKEDIN_REDIRECT_URI,
      scope: scope
    }));
});

// LinkedIn Callback
app.get('/linkedin/callback', async (req, res) => {
  const code = req.query.code || null;
  
  try {
    const response = await axios.post('https://www.linkedin.com/oauth/v2/accessToken',
      querystring.stringify({
        grant_type: 'authorization_code',
        code: code,
        redirect_uri: LINKEDIN_REDIRECT_URI,
        client_id: LINKEDIN_CLIENT_ID,
        client_secret: LINKEDIN_CLIENT_SECRET
      }), {
        headers: {
          'Content-Type': 'application/x-www-form-urlencoded'
        }
      });
    
    tokens.linkedin = {
      access_token: response.data.access_token,
      expires_at: Date.now() + (response.data.expires_in * 1000)
    };
    
    res.redirect('/?linkedin=connected');
  } catch (error) {
    console.error('LinkedIn auth error:', error.response?.data || error.message);
    res.redirect('/?error=linkedin_auth_failed');
  }
});

// Refresh Spotify Token
async function refreshSpotifyToken() {
  if (!tokens.spotify?.refresh_token) return false;
  
  try {
    const response = await axios.post('https://accounts.spotify.com/api/token',
      querystring.stringify({
        grant_type: 'refresh_token',
        refresh_token: tokens.spotify.refresh_token
      }), {
        headers: {
          'Authorization': 'Basic ' + Buffer.from(SPOTIFY_CLIENT_ID + ':' + SPOTIFY_CLIENT_SECRET).toString('base64'),
          'Content-Type': 'application/x-www-form-urlencoded'
        }
      });
    
    tokens.spotify.access_token = response.data.access_token;
    tokens.spotify.expires_at = Date.now() + (response.data.expires_in * 1000);
    return true;
  } catch (error) {
    console.error('Token refresh error:', error.message);
    return false;
  }
}

// Get Currently Playing
app.get('/api/now-playing', async (req, res) => {
  if (!tokens.spotify) {
    return res.status(401).json({ error: 'Not authenticated with Spotify' });
  }
  
  if (Date.now() >= tokens.spotify.expires_at) {
    await refreshSpotifyToken();
  }
  
  try {
    const response = await axios.get('https://api.spotify.com/v1/me/player/currently-playing', {
      headers: {
        'Authorization': `Bearer ${tokens.spotify.access_token}`
      }
    });
    
    if (response.status === 204 || !response.data) {
      return res.json({ is_playing: false });
    }
    
    const track = response.data.item;
    res.json({
      is_playing: response.data.is_playing,
      track_name: track.name,
      artist: track.artists.map(a => a.name).join(', '),
      album: track.album.name,
      album_art: track.album.images[0]?.url
    });
  } catch (error) {
    console.error('Spotify API error:', error.response?.status, error.response?.data);
    res.status(500).json({ error: 'Failed to fetch currently playing' });
  }
});

// Post to LinkedIn
app.post('/api/post-to-linkedin', async (req, res) => {
  if (!tokens.linkedin) {
    return res.status(401).json({ error: 'Not authenticated with LinkedIn' });
  }
  
  const { text } = req.body;
  
  try {
    // Get LinkedIn user ID
    const userResponse = await axios.get('https://api.linkedin.com/v2/userinfo', {
      headers: {
        'Authorization': `Bearer ${tokens.linkedin.access_token}`
      }
    });
    
    const userId = userResponse.data.sub;
    
    // Post to LinkedIn
    const postResponse = await axios.post('https://api.linkedin.com/v2/ugcPosts', {
      author: `urn:li:person:${userId}`,
      lifecycleState: 'PUBLISHED',
      specificContent: {
        'com.linkedin.ugc.ShareContent': {
          shareCommentary: {
            text: text
          },
          shareMediaCategory: 'NONE'
        }
      },
      visibility: {
        'com.linkedin.ugc.MemberNetworkVisibility': 'PUBLIC'
      }
    }, {
      headers: {
        'Authorization': `Bearer ${tokens.linkedin.access_token}`,
        'Content-Type': 'application/json',
        'X-Restli-Protocol-Version': '2.0.0'
      }
    });
    
    res.json({ success: true, post_id: postResponse.data.id });
  } catch (error) {
    console.error('LinkedIn post error:', error.response?.data || error.message);
    res.status(500).json({ error: 'Failed to post to LinkedIn' });
  }
});

// Check authentication status
app.get('/api/status', (req, res) => {
  res.json({
    spotify: !!tokens.spotify,
    linkedin: !!tokens.linkedin
  });
});

app.listen(PORT, () => {
  console.log(`Server running on port ${PORT}`);
});