from flask import Flask, request, jsonify
from flask_sqlalchemy import SQLAlchemy

app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'your_postgresql_connection_string'
db = SQLAlchemy(app)

# User model
class User(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(50), nullable=False)
    # define relationships with other models
    liked_posts = db.relationship('PostLike', backref='user', lazy=True)
    followed_users = db.relationship('Follow', foreign_keys='Follow.follower_id', backref='follower', lazy=True)
    followers = db.relationship('Follow', foreign_keys='Follow.followed_id', backref='followed', lazy=True)
    comments = db.relationship('Comment', backref='user', lazy=True)
    posts = db.relationship('Post', backref='user', lazy=True)

# Post model
class Post(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
    title = db.Column(db.String(100), nullable=False)
    body = db.Column(db.Text, nullable=False)
    # define relationships with other models
    likes = db.relationship('PostLike', backref='post', lazy=True)
    comments = db.relationship('Comment', backref='post', lazy=True)

# PostLike model
class PostLike(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
    post_id = db.Column(db.Integer, db.ForeignKey('post.id'), nullable=False)

# Follow model
class Follow(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    follower_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
    followed_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)

# Comment model
class Comment(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
    post_id = db.Column(db.Integer, db.ForeignKey('post.id'), nullable=False)
    body = db.Column(db.Text, nullable=False)

# Post Service
@app.route('/create_post', methods=['POST'])
def create_post():
    # create post in database
    post = Post(
        user_id=request.json['user_id'],
        title=request.json['title'],
        body=request.json['body']
    )
    db.session.add(post)
    db.session.commit()
    return 'Post created successfully'

@app.route('/get_posts', methods=['GET'])
def get_posts():
    # retrieve all posts from database
    posts = Post.query.all()
    # return posts in JSON format
    return jsonify([post.__dict__ for post in posts])

# Like Service
@app.route('/like_post', methods=['POST'])
def like_post():
    # create like in database
    like = PostLike(
        user_id=request.json['user_id'],
        post_id=request.json['post_id']
    )
    db.session.add(like)
    db.session.commit()
    return 'Post liked successfully'

# Follow Service
@app.route('/follow_user', methods=['POST'])
def follow_user():
    # create follow in database
    follow = Follow(
        follower_id=request.json['follower_id'],
        followed_id=request.json['followed_id']
    )
    db.session.add(follow)
    db.session.commit()
    return 'User followed successfully'

@app.route('/get_followed_users', methods=['GET'])
def get_followed_users():
    # retrieve all followed users for a given user
    user_id = request.args.get('user_id')
    followed_users = Follow.query.filter_by(follower_id=user_id).all()
    # return followed users in JSON format
    return jsonify([followed_user.followed.__dict__ for followed_user in followed_users])

@app.route('/get_followers', methods=['GET'])
def get_followers():
    # retrieve all followers for a given user
    user_id = request.args.get('user_id')
    followers = Follow.query.filter_by(followed_id=user_id).all()
    # return followers in JSON format
    return jsonify([follower.follower.__dict__ for follower in followers])

# Generate Feed service
@app.route('/generate_feed', methods=['GET'])
def generate_feed():
    user_id = request.args.get('user_id')
    followed_users = Follow.query.filter_by(follower_id=user_id).all()
    post_ids = [followed_user.followed.posts for followed_user in followed_users]
    post_ids = list(set([post.id for sublist in post_ids for post in sublist]))
    posts = Post.query.filter(Post.id.in_(post_ids)).order_by(Post.timestamp.desc()).all()
    feed = []
    for post in posts:
        likes = Like.query.filter_by(post_id=post.id).all()
        comments = Comment.query.filter_by(post_id=post.id).all()
        post_dict = post.__dict__
        post_dict.pop('_sa_instance_state')
        post_dict['likes'] = [like.user_id for like in likes]
        post_dict['comments'] = [comment.__dict__ for comment in comments]
        feed.append(post_dict)
    return jsonify(feed)

public class User {
    private String username;
    private String password;
    private String email;
    // ...

    public User(String username, String password, String email) {
        this.username = username;
        this.password = password;
        this.email = email;
    }

    // Getters and setters
    // ...
}

public class UserManager {
    private Map<String, User> users;

    public UserManager() {
        this.users = new HashMap<>();
    }

    public void registerUser(String username, String password, String email) {
        if (!users.containsKey(username)) {
            User newUser = new User(username, password, email);
            users.put(username, newUser);
            System.out.println("User registered successfully.");
        } else {
            System.out.println("Username already exists. Please choose a different username.");
        }
    }

    public User loginUser(String username, String password) {
        User user = users.get(username);
        if (user != null && user.getPassword().equals(password)) {
            System.out.println("Login successful.");
            return user;
        } else {
            System.out.println("Invalid username or password.");
            return null;
        }
    }

    // Other user management methods
    // ...
}
public class Media {
    private String mediaId;
    private String title;
    private String description;
    private List<String> tags;
    // ...

    public Media(String mediaId, String title, String description, List<String> tags) {
        this.mediaId = mediaId;
        this.title = title;
        this.description = description;
        this.tags = tags;
    }

    // Getters and setters
    // ...
}

public class MediaUploadManager {
    public void uploadMedia(User user, String title, String description, List<String> tags, InputStream mediaStream) {
        // Generate a unique media ID
        String mediaId = generateUniqueId();

        // Store media file in a distributed storage system
        boolean isStored = storeMediaInDistributedSystem(mediaId, mediaStream);

        if (isStored) {
            // Create a Media object
            Media media = new Media(mediaId, title, description, tags);

            // Store media metadata in a database
            saveMediaMetadata(media);

            // Associate media with the user
            user.addMedia(media);

            System.out.println("Media uploaded successfully.");
        } else {
            System.out.println("Failed to store media file.");
        }
    }

    // Other media upload methods
    // ...
}

Endpoint: GET /search/photos
Parameters:
- query: string (required)
- page: integer (optional, default=1)
- per_page: integer (optional, default=10)
Returns:
- List of photo objects in JSON format:
    - photo_id: string
    - owner: string
    - secret: string
    - server: integer
    - farm: integer
    - title: string

Endpoint: GET /photos/<photo_id>
Parameters:
- photo_id: string (required)
Returns:
- Photo object in JSON format:
    - photo_id: string
    - owner: string
    - secret: string
    - server: integer
    - farm: integer
    - title: string
    - description: string
    - tags: list of strings

Endpoint: GET /users/<user_id>
Parameters:
- user_id: string (required)
Returns:
- User object in JSON format:
    - user_id: string
    - username: string
    - realname: string
    - location: string
    - profile_image: string

Endpoint: GET /users/<user_id>/photos
Parameters:
- user_id: string (required)
- page: integer (optional, default=1)
- per_page: integer (optional, default=10)
Returns:
- List of photo objects in JSON format:
    - photo_id: string
    - owner: string
    - secret: string
    - server: integer
    - farm: integer
    - title: string

Endpoint: GET /tags/popular
Parameters:
- limit: integer (optional, default=10)
Returns:
- List of tag objects in JSON format:
    - name: string
    - count: integer

import requests
from flask import Flask, jsonify

app = Flask(__name__)

# API key for the Flickr API
api_key = 'your_api_key'

# Endpoint to search for photos
@app.route('/search/photos')
def search_photos():
    query = request.args.get('query')
    page = request.args.get('page', 1)
    per_page = request.args.get('per_page', 10)
    url = f'https://api.flickr.com/services/rest/?method=flickr.photos.search&api_key={api_key}&text={query}&page={page}&per_page={per_page}&format=json&nojsoncallback=1'
    response = requests.get(url)
    data = response.json()
    photos = data['photos']['photo']
    result = []
    for photo in photos:
        photo_dict = {
            'photo_id': photo['id'],
            'owner': photo['owner'],
            'secret': photo['secret'],
            'server': photo['server'],
            'farm': photo['farm'],
            'title': photo['title']
        }
        result.append(photo_dict)
    return jsonify(result)

# Endpoint to get photo details
@app.route('/photos/<photo_id>')
def get_photo(photo_id):
    url = f'https://api.flickr.com/services/rest/?method=flickr.photos.getInfo&api_key={api_key}&photo_id={photo_id}&format=json&nojsoncallback=1'
    response = requests.get(url)
    data = response.json()
    photo = data['photo']
    photo_dict = {
        'photo_id': photo['id'],
        'owner': photo['owner']['nsid'],
        'secret': photo['secret'],
        'server': photo['server'],
        'farm': photo['farm'],
        'title': photo['title']['_content'],
        'description': photo['description']['_content'],
        'tags': [tag['_content'] for tag in photo['tags']['tag']]
    }
    return jsonify(photo_dict)

# Endpoint to get user information
@app.route('/users/<user_id>')
def get_user(user_id):
    url = f'https://api.flickr.com/services/rest/?method=flickr.people.getInfo&api_key={api_key}&user_id={user_id}&format=json&nojsoncallback=1'
    response = requests.get(url)
    data = response.json()
    user = data['person']
    user_dict = {
        'user_id': user['id'],
        'username': user['username']['_content'],
        'realname': user['realname']['_content'],
        'location': user['location']['_content'],
        'profile_image': f'https://farm{user["iconfarm"]}.staticflickr.com/{user["iconserver"]}/buddyicons/{user["nsid"]}.jpg'
    }
    return jsonify(user_dict)
# Endpoint to get user photos
@app.route('/users/<user_id>/photos')
def get_user_photos(user_id):
    page = request.args.get('page', 1)
    per_page = request.args.get('per_page', 10)
    url = f'https://api.flickr.com/services/rest/?method=flickr.people.getPublicPhotos&api_key={api_key}&user_id={user_id}&page={page}&per_page={per_page}&format=json&nojsoncallback=1'
    response = requests.get(url)
    data = response.json()
    photos = data['photos']['photo']
    result = []
    for photo in photos:
        photo_dict = {
            'photo_id': photo['id'],
            'owner': photo['owner'],
            'secret': photo['secret'],
            'server': photo['server'],
            'farm': photo['farm'],
            'title': photo['title']
        }
        result.append(photo_dict)
    return jsonify(result)