// Microsoft Graph API for Teams
class TeamsGraphAPI {
    constructor(clientId, clientSecret, tenantId) {
        this.clientId = clientId;
        this.clientSecret = clientSecret;
        this.tenantId = tenantId;
        this.baseURL = 'https://graph.microsoft.com/v1.0';
    }
    
    async getAccessToken() {
        const tokenEndpoint = `https://login.microsoftonline.com/${this.tenantId}/oauth2/v2.0/token`;
        
        const response = await fetch(tokenEndpoint, {
            method: 'POST',
            headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
            body: new URLSearchParams({
                client_id: this.clientId,
                client_secret: this.clientSecret,
                scope: 'https://graph.microsoft.com/.default',
                grant_type: 'client_credentials'
            })
        });
        
        const data = await response.json();
        return data.access_token;
    }
    
    async createTeam(teamData) {
        const token = await this.getAccessToken();
        
        const response = await fetch(`${this.baseURL}/teams`, {
            method: 'POST',
            headers: {
                'Authorization': `Bearer ${token}`,
                'Content-Type': 'application/json'
            },
            body: JSON.stringify({
                'template@odata.bind': 'https://graph.microsoft.com/v1.0/teamsTemplates/standard',
                displayName: teamData.name,
                description: teamData.description,
                members: teamData.members.map(member => ({
                    '@odata.type': '#microsoft.graph.aadUserConversationMember',
                    'user@odata.bind': `https://graph.microsoft.com/v1.0/users('${member.userId}')`,
                    roles: member.roles || ['member']
                }))
            })
        });
        
        return response.json();
    }
    
    async sendMessage(teamId, channelId, message) {
        const token = await this.getAccessToken();
        
        const response = await fetch(`${this.baseURL}/teams/${teamId}/channels/${channelId}/messages`, {
            method: 'POST',
            headers: {
                'Authorization': `Bearer ${token}`,
                'Content-Type': 'application/json'
            },
            body: JSON.stringify({
                body: {
                    contentType: 'html',
                    content: message
                }
            })
        });
        
        return response.json();
    }
    
    async scheduleRecurringMeeting(meetingData) {
        const token = await this.getAccessToken();
        
        const response = await fetch(`${this.baseURL}/me/events`, {
            method: 'POST',
            headers: {
                'Authorization': `Bearer ${token}`,
                'Content-Type': 'application/json'
            },
            body: JSON.stringify({
                subject: meetingData.subject,
                start: {
                    dateTime: meetingData.startTime,
                    timeZone: meetingData.timeZone
                },
                end: {
                    dateTime: meetingData.endTime,
                    timeZone: meetingData.timeZone
                },
                recurrence: {
                    pattern: {
                        type: meetingData.recurrenceType,
                        interval: meetingData.interval,
                        daysOfWeek: meetingData.daysOfWeek
                    },
                    range: {
                        type: 'endDate',
                        startDate: meetingData.startDate,
                        endDate: meetingData.endDate
                    }
                },
                attendees: meetingData.attendees.map(email => ({
                    emailAddress: { address: email, name: email },
                    type: 'required'
                })),
                isOnlineMeeting: true,
                onlineMeetingProvider: 'teamsForBusiness'
            })
        });
        
        return response.json();
    }
}

// Teams Bot Development
const { TeamsActivityHandler, MessageFactory, CardFactory } = require('botbuilder');

class TeamsBot extends TeamsActivityHandler {
    constructor() {
        super();
        
        this.onMessage(async (context, next) => {
            const text = context.activity.text.toLowerCase();
            
            switch (true) {
                case text.includes('help'):
                    await this.sendHelpCard(context);
                    break;
                    
                case text.includes('meeting'):
                    await this.scheduleMeeting(context);
                    break;
                    
                case text.includes('status'):
                    await this.getProjectStatus(context);
                    break;
                    
                default:
                    await context.sendActivity('I didn\'t understand that. Type "help" for available commands.');
            }
            
            await next();
        });
        
        this.onMembersAdded(async (context, next) => {
            const welcomeText = 'Welcome to the team! I\'m here to help with meeting scheduling and project updates.';
            await context.sendActivity(MessageFactory.text(welcomeText));
            await next();
        });
    }
    
    async sendHelpCard(context) {
        const card = CardFactory.adaptiveCard({
            type: 'AdaptiveCard',
            version: '1.2',
            body: [
                {
                    type: 'TextBlock',
                    text: 'Available Commands',
                    weight: 'Bolder',
                    size: 'Medium'
                },
                {
                    type: 'TextBlock',
                    text: '• **meeting** - Schedule a new meeting\n• **status** - Get project status\n• **help** - Show this help',
                    wrap: true
                }
            ],
            actions: [
                {
                    type: 'Action.Submit',
                    title: 'Schedule Meeting',
                    data: { action: 'schedule_meeting' }
                },
                {
                    type: 'Action.Submit',
                    title: 'Project Status',
                    data: { action: 'project_status' }
                }
            ]
        });
        
        await context.sendActivity(MessageFactory.attachment(card));
    }
    
    async scheduleMeeting(context) {
        const meetingCard = CardFactory.adaptiveCard({
            type: 'AdaptiveCard',
            version: '1.2',
            body: [
                {
                    type: 'TextBlock',
                    text: 'Schedule a Meeting',
                    weight: 'Bolder'
                },
                {
                    type: 'Input.Text',
                    id: 'title',
                    placeholder: 'Meeting title'
                },
                {
                    type: 'Input.Date',
                    id: 'date',
                    title: 'Date'
                },
                {
                    type: 'Input.Time',
                    id: 'time',
                    title: 'Time'
                },
                {
                    type: 'Input.Text',
                    id: 'attendees',
                    placeholder: 'Attendee emails (comma separated)',
                    isMultiline: true
                }
            ],
            actions: [
                {
                    type: 'Action.Submit',
                    title: 'Create Meeting',
                    data: { action: 'create_meeting' }
                }
            ]
        });
        
        await context.sendActivity(MessageFactory.attachment(meetingCard));
    }
    
    async getProjectStatus(context) {
        // Fetch project data from external API
        const projectData = await this.fetchProjectData();
        
        const statusCard = CardFactory.adaptiveCard({
            type: 'AdaptiveCard',
            version: '1.2',
            body: [
                {
                    type: 'TextBlock',
                    text: 'Project Status Dashboard',
                    weight: 'Bolder',
                    size: 'Medium'
                },
                {
                    type: 'FactSet',
                    facts: [
                        { title: 'Active Tasks', value: projectData.activeTasks },
                        { title: 'Completed', value: projectData.completedTasks },
                        { title: 'Team Members', value: projectData.teamSize },
                        { title: 'Next Deadline', value: projectData.nextDeadline }
                    ]
                }
            ]
        });
        
        await context.sendActivity(MessageFactory.attachment(statusCard));
    }
}

// Teams Webhook Integration
class TeamsWebhooks {
    constructor(webhookUrl) {
        this.webhookUrl = webhookUrl;
    }
    
    async sendNotification(notification) {
        const message = {
            '@type': 'MessageCard',
            '@context': 'https://schema.org/extensions',
            summary: notification.summary,
            themeColor: notification.color || '0078D4',
            sections: [
                {
                    activityTitle: notification.title,
                    activitySubtitle: notification.subtitle,
                    activityImage: notification.image,
                    facts: notification.facts || [],
                    text: notification.text
                }
            ],
            potentialAction: notification.actions || []
        };
        
        const response = await fetch(this.webhookUrl, {
            method: 'POST',
            headers: { 'Content-Type': 'application/json' },
            body: JSON.stringify(message)
        });
        
        return response.ok;
    }
    
    async sendDeploymentNotification(deployment) {
        return this.sendNotification({
            summary: 'Deployment Status',
            title: `Deployment ${deployment.status}`,
            subtitle: `${deployment.application} v${deployment.version}`,
            color: deployment.status === 'success' ? '00FF00' : 'FF0000',
            facts: [
                { name: 'Environment', value: deployment.environment },
                { name: 'Duration', value: deployment.duration },
                { name: 'Deployed by', value: deployment.deployer }
            ],
            actions: [
                {
                    '@type': 'OpenUri',
                    name: 'View Logs',
                    targets: [{ os: 'default', uri: deployment.logsUrl }]
                }
            ]
        });
    }
    
    async sendMeetingReminder(meeting) {
        return this.sendNotification({
            summary: 'Meeting Reminder',
            title: meeting.title,
            subtitle: `Starting in ${meeting.timeUntil}`,
            color: 'FFD700',
            facts: [
                { name: 'Time', value: meeting.startTime },
                { name: 'Duration', value: meeting.duration },
                { name: 'Organizer', value: meeting.organizer }
            ],
            actions: [
                {
                    '@type': 'OpenUri',
                    name: 'Join Meeting',
                    targets: [{ os: 'default', uri: meeting.joinUrl }]
                }
            ]
        });
    }
}