#include <string>
#include <iostream>
#include "PlaylistNode.h"
using namespace std;

PlaylistNode::PlaylistNode() {
   uniqueID = "none";
   songName = "none";
   artistName = "none";
   songLength = 0;
   nextNodePtr = 0;
}

PlaylistNode::PlaylistNode(string uniqueID_, string songName_, string artistName_, int songLength_) {
   uniqueID = uniqueID_;
   songName = songName_;
   artistName = artistName_;
   songLength = songLength_;
   nextNodePtr = 0;
}

void PlaylistNode::InsertAfter(PlaylistNode* ptr) {
   this->SetNext(ptr->GetNext());
   ptr->SetNext(this);
}

void PlaylistNode::SetNext(PlaylistNode* ptr) {
   nextNodePtr = ptr;
}

string PlaylistNode::GetID() {
   return uniqueID;
}

string PlaylistNode::GetSongName() {
   return songName;
}

string PlaylistNode::GetArtistName() {
   return artistName;
}

int PlaylistNode::GetSongLength() {
   return songLength;
}

PlaylistNode* PlaylistNode::GetNext() {
   return nextNodePtr;
}

void PlaylistNode::PrintPlaylistNode() {
   cout << "Unique ID: " << uniqueID << endl;
   cout << "Song Name: " << songName << endl;
   cout << "Artist Name: " << artistName << endl;
   cout << "Song Length (in seconds): " << songLength << endl;
}

Playlist::Playlist() {
   head = tail = 0;
}

void Playlist::AddSong(string id, string songname, string artistname, int length) {
   PlaylistNode* n = new PlaylistNode(id, songname, artistname, length);
   if (head == 0) {
      head = tail = n;
   }
   else {
      n->InsertAfter(tail);
      tail = n;
   }
}

bool Playlist::RemoveSong(string id) {
   if (head == NULL) {
      cout << "Playlist is empty" << endl;
      return false;
   }
   
   PlaylistNode* curr = head;
   PlaylistNode* prev = NULL;
   while (curr != NULL) {
      if (curr->GetID() == id) {
         break;
      }
      prev = curr;
      curr = curr->GetNext();
   }
   
   if (curr == NULL) {
      cout << "\"" << curr->GetSongName() << "\" is not found" << endl;
      return false;
   }
   else {
      if (prev != NULL) {
         prev ->SetNext(curr->GetNext());
      }
      else {
         head = curr->GetNext();
      }
      if (tail == curr) {
         tail = prev;
      }
      cout << "\"" << curr->GetSongName() << "\" removed." << endl;
      delete curr;
      return true;
   }
}

bool Playlist::ChangePosition(int oldPos, int newPos) {
   if (head == NULL) {
      cout << "Playlist is empty" << endl;
      return false;
   }
   
   PlaylistNode* prev = NULL;
   PlaylistNode* curr = head;
   
   int pos;
   if (head == NULL || head == tail) {
      return false;
   }
   
   for (pos = 1; curr != NULL && pos < oldPos; pos++) {
      prev = curr;
      curr = curr->GetNext();
   }
   if (curr != NULL) {
      string currentSong = curr->GetSongName();
      
      if (prev == NULL) {
         head = curr->GetNext();
      }
      else {
         prev->SetNext(curr->GetNext());
      }
      if (curr == tail) {
         tail = prev;
      }
      
      PlaylistNode* curr1 = curr;
      prev = NULL;
      curr = head;
      for (pos = 1; curr != NULL && pos < newPos; pos++) {
         prev = curr;
         curr = curr->GetNext();
      }
      if (prev == NULL) {
         curr1->SetNext(head);
         head = curr1;
      }
      else {
         curr1->InsertAfter(prev);
      }
      if (curr == NULL) {
         tail = curr1;
      }
      cout << "\"" << currentSong << "\" moved to position " << newPos << endl;
      return true;
   }
   else {
      cout << "Song's current position is invalid" << endl;
      return false;
   }
}

void Playlist::SongsByArtist(string artist) {
   if (head == NULL) {
      cout << "Playlist is empty" << endl;
   }
   else {
      PlaylistNode* curr = head;
      int i = 1;
      while (curr != NULL) {
         if (curr->GetArtistName() == artist) {
            cout << endl << i << "." << endl;
            curr->PrintPlaylistNode();
         }
         curr = curr->GetNext();
         i++;
      }
   }
}

int Playlist::TotalTime() {
   int total = 0;
   PlaylistNode* curr = head;
   
   while (curr != NULL) {
      total += curr->GetSongLength();
      curr = curr->GetNext();
   }
   return total;
}

void Playlist::PrintList() {
   if (head == NULL) {
      cout << "Playlist is empty" << endl;
   }
   else {
      PlaylistNode* curr = head;
      int i = 1;
      while (curr != NULL) {
         cout << endl << i++ << "." << endl;
         curr->PrintPlaylistNode();
         curr = curr->GetNext();
      }
   }
}

/*
Good morning! Here's your coding interview problem for today.

This problem was asked by Stripe.

Given an array of integers, find the first missing positive integer in linear time and constant space. In other words, find the lowest positive integer that does not exist in the array. The array can contain duplicates and negative numbers as well.

For example, the input [3, 4, -1, 1] should give 2. The input [1, 2, 0] should give 3.

You can modify the input array in-place.
*/
#include <iostream>
using namespace std;

int calcMissing(int* input, int size)
{
	int sum = 0;
	int n = 1; //add one to account for missing value
	for(int i = 0; i < size; i++)
	{
	if(input[i] > 0)
	{
	sum += input[i];
	n++;
	}
	}

	//If no numbers higher than 0, answer is 1
	if(sum == 0)
	return 1;

	return (n*(n+1)/2) - sum; //Formula is expectedSum - actualSum
	/* expectedSum = n*(n+1)/2, the formula for sum(1, n) */
}

int main()
{

	cout << calcMissing(new int[4]{3, 4, -1, 1}, 4) << endl;
	cout << calcMissing(new int[3]{1, 2, 0}, 3) << endl;

	//No positive numbers
	cout << calcMissing(new int[1]{0}, 1) << endl;
}

#include <iostream>
using namespace std;
int main()
{
    int arr[] = {5, 1, 4, 20, 10, 2, 13, 11, 6, 21};
    int greed[] = {0, 0, 0, 0};
    int k = 0;
    int i;
    int set_index;
    while (k < 4)
    {
        i = 0;
        while (i < 10)
        {
            if (arr[i] > greed[k])
            {
                greed[k] = arr[i];
                set_index = i;
            }
            i++;
        }
        arr[set_index] = 0;
        k++;
    }
    cout << greed[0] << " " << greed[1] << " " << greed[2] << " " << greed[3] << endl;
}

#include <iostream>
#include "PlaylistNode.h"
using namespace std;
void PrintMenu(string title);

int main() {
   string plTitle;
   cout << "Enter playlist's title:" << endl;
   getline(cin, plTitle);
   PrintMenu(plTitle);
   return 0;
}

void PrintMenu(string title) {
   Playlist list;
   string id;
   string sname;
   string aname;
   int length;
   int oldPos;
   int newPos;
   char choice;
   
   while(true) {
      cout << endl << title << " PLAYLIST MENU" << endl;
      cout << "a - Add song" << endl;
      cout << "d - Remove song" << endl;
      cout << "c - Change position of song" << endl;
      cout << "s - Output songs by specific artist" << endl;
      cout << "t - Output total time of playlist (in seconds)" << endl;
      cout << "o - Output full playlist" << endl;
      cout << "q - Quit" << endl << endl;
      
      cout << "Choose an option:" << endl;
      cin >> choice;
      cin.ignore();
      
      if (choice == 'q') {
         exit(1);
      }
      else if (choice == 'a') {
         cout << "\nADD SONG" << endl;
         cout << "Enter song's unique ID: ";
         cin >> id;
         cin.ignore();
         cout << "Enter song's name: ";
         getline(cin,sname);
         cout << "Enter artist's name: ";
         getline(cin,aname);
         cout << "Enter song's length (in seconds): ";
         cin >> length;
         list.AddSong(id, sname, aname, length);
      }
      else if (choice == 'd') {
         cout << "\nREMOVE SONG" << endl;
         cout << "Enter song's unique ID: ";
         cin >> id;
         list.RemoveSong(id);
      }
      else if (choice == 'c') {
         cout << "\nCHANGE POSITION OF SONG" << endl;
         cout << "Enter song's current position: ";
         cin >> oldPos;
         cout << "Enter new position for song: ";
         cin >> newPos;
         list.ChangePosition(oldPos, newPos);
      }
      else if (choice == 's') {
         cout << "\nOUTPUT SONGS BY SPECIFIC ARTIST" << endl;
         cout << "Enter artist's name: ";
         getline(cin, aname);
         list.SongsByArtist(aname);
      }
      else if (choice == 't') {
         cout << "\nOUTPUT TOTAL TIME OF PLAYLIST (IN SECONDS)" << endl;
         cout << "Total time: " << list.TotalTime() << " seconds" << endl;
      }
      else if (choice == 'o') {
         cout << endl << title << " - OUTPUT FULL PLAYLIST" << endl;
         list.PrintList();
      }
      else {
         cout << "Invalid menu choice! Please try again." << endl;
      }
   }
}

//Leif Messinger
//Compile with C++ 20
#include <iostream>
#include <ranges>
#include <vector>
#include <functional>
#include <cctype> //toupper
#include <cxxabi.h>

template <typename T>
void printType(){
    std::cout << abi::__cxa_demangle(typeid(T).name(), NULL, NULL, NULL) << std::endl;
}

template <typename T>
class Slicer{
    public:
        T begin_;
        T end_;
        T trueEnd;
        Slicer(T begin, T end): begin_(begin), end_(begin), trueEnd(end){}
        template<typename U>
        Slicer(U&& vec) : begin_(vec.begin()), end_(vec.begin()), trueEnd(vec.end()){}
        Slicer& finish(){
            begin_ = end_;
            end_ = trueEnd;
            return (*this);
        }
        Slicer& to(long int index){
            begin_ = end_;
            if(index > 0){
                end_ = (begin_ + index);
            }else{
                index *= -1;
                end_ = (trueEnd - index);
            }
            return (*this);
        }
        Slicer& operator[](long int index){
            return to(index);
        }
        T begin(){
            return this->begin_;
        }
        T end(){
            return this->end_;
        }
        Slicer& operator()(std::function<void(decltype(*begin_))> func) {
            for(decltype(*begin_) thing : (*this)){
                func(thing);
            }
            return (*this);
        }
};
static_assert(std::ranges::range< Slicer<std::vector<int>::const_iterator> >);

int main(){
    std::string vec = "abcdefghijklmnopqrstuvwxyz";
    Slicer<std::string::const_iterator> bruh(vec);
    
    //printType<decltype(bruh)>();

    bruh.to(3)([](char yeet){
        std::cout << yeet;
    })
    .to(-1)([](char yeet){
        std::cout << char(std::toupper(yeet));
    }).finish()([](char yeet){
        std::cout << yeet << yeet << yeet << yeet << yeet;
    });
    
    std::cout << std::endl << std::endl;
    
    int arr[] = {1, 2, 3, 4, 5, 6, 7, 8};
    Slicer<int*> arrSlicer(arr, arr + (sizeof(arr)/sizeof(int)));
    
    std::cout << "[";
    arrSlicer.to(-1)([](int yeet){
        std::cout << yeet << ", ";
    }).finish()([](int yeet){
        std::cout << yeet << "]" << std::endl;
    });

    return 0;
}

#include <iostream>
#include <vector>
#include <utility>
#include <algorithm>
#include <chrono>
using namespace std;

#include <stdio.h>
#include <Windows.h>

int nScreenWidth = 120;			// Console Screen Size X (columns)
int nScreenHeight = 40;			// Console Screen Size Y (rows)
int nMapWidth = 16;				// World Dimensions
int nMapHeight = 16;

float fPlayerX = 14.7f;			// Player Start Position
float fPlayerY = 5.09f;
float fPlayerA = 0.0f;			// Player Start Rotation
float fFOV = 3.14159f / 4.0f;	// Field of View
float fDepth = 16.0f;			// Maximum rendering distance
float fSpeed = 5.0f;			// Walking Speed

int main()
{
	// Create Screen Buffer
	wchar_t *screen = new wchar_t[nScreenWidth*nScreenHeight];
	HANDLE hConsole = CreateConsoleScreenBuffer(GENERIC_READ | GENERIC_WRITE, 0, NULL, CONSOLE_TEXTMODE_BUFFER, NULL);
	SetConsoleActiveScreenBuffer(hConsole);
	DWORD dwBytesWritten = 0;

	// Create Map of world space # = wall block, . = space
	wstring map;
	map += L"#########.......";
	map += L"#...............";
	map += L"#.......########";
	map += L"#..............#";
	map += L"#......##......#";
	map += L"#......##......#";
	map += L"#..............#";
	map += L"###............#";
	map += L"##.............#";
	map += L"#......####..###";
	map += L"#......#.......#";
	map += L"#......#.......#";
	map += L"#..............#";
	map += L"#......#########";
	map += L"#..............#";
	map += L"################";

	auto tp1 = chrono::system_clock::now();
	auto tp2 = chrono::system_clock::now();
	
	while (1)
	{
		// We'll need time differential per frame to calculate modification
		// to movement speeds, to ensure consistant movement, as ray-tracing
		// is non-deterministic
		tp2 = chrono::system_clock::now();
		chrono::duration<float> elapsedTime = tp2 - tp1;
		tp1 = tp2;
		float fElapsedTime = elapsedTime.count();


		// Handle CCW Rotation
		if (GetAsyncKeyState((unsigned short)'A') & 0x8000)
			fPlayerA -= (fSpeed * 0.75f) * fElapsedTime;

		// Handle CW Rotation
		if (GetAsyncKeyState((unsigned short)'D') & 0x8000)
			fPlayerA += (fSpeed * 0.75f) * fElapsedTime;
		
		// Handle Forwards movement & collision
		if (GetAsyncKeyState((unsigned short)'W') & 0x8000)
		{
			fPlayerX += sinf(fPlayerA) * fSpeed * fElapsedTime;;
			fPlayerY += cosf(fPlayerA) * fSpeed * fElapsedTime;;
			if (map.c_str()[(int)fPlayerX * nMapWidth + (int)fPlayerY] == '#')
			{
				fPlayerX -= sinf(fPlayerA) * fSpeed * fElapsedTime;;
				fPlayerY -= cosf(fPlayerA) * fSpeed * fElapsedTime;;
			}			
		}

		// Handle backwards movement & collision
		if (GetAsyncKeyState((unsigned short)'S') & 0x8000)
		{
			fPlayerX -= sinf(fPlayerA) * fSpeed * fElapsedTime;;
			fPlayerY -= cosf(fPlayerA) * fSpeed * fElapsedTime;;
			if (map.c_str()[(int)fPlayerX * nMapWidth + (int)fPlayerY] == '#')
			{
				fPlayerX += sinf(fPlayerA) * fSpeed * fElapsedTime;;
				fPlayerY += cosf(fPlayerA) * fSpeed * fElapsedTime;;
			}
		}

		for (int x = 0; x < nScreenWidth; x++)
		{
			// For each column, calculate the projected ray angle into world space
			float fRayAngle = (fPlayerA - fFOV/2.0f) + ((float)x / (float)nScreenWidth) * fFOV;

			// Find distance to wall
			float fStepSize = 0.1f;		  // Increment size for ray casting, decrease to increase										
			float fDistanceToWall = 0.0f; //                                      resolution

			bool bHitWall = false;		// Set when ray hits wall block
			bool bBoundary = false;		// Set when ray hits boundary between two wall blocks

			float fEyeX = sinf(fRayAngle); // Unit vector for ray in player space
			float fEyeY = cosf(fRayAngle);

			// Incrementally cast ray from player, along ray angle, testing for 
			// intersection with a block
			while (!bHitWall && fDistanceToWall < fDepth)
			{
				fDistanceToWall += fStepSize;
				int nTestX = (int)(fPlayerX + fEyeX * fDistanceToWall);
				int nTestY = (int)(fPlayerY + fEyeY * fDistanceToWall);
				
				// Test if ray is out of bounds
				if (nTestX < 0 || nTestX >= nMapWidth || nTestY < 0 || nTestY >= nMapHeight)
				{
					bHitWall = true;			// Just set distance to maximum depth
					fDistanceToWall = fDepth;
				}
				else
				{
					// Ray is inbounds so test to see if the ray cell is a wall block
					if (map.c_str()[nTestX * nMapWidth + nTestY] == '#')
					{
						// Ray has hit wall
						bHitWall = true;

						// To highlight tile boundaries, cast a ray from each corner
						// of the tile, to the player. The more coincident this ray
						// is to the rendering ray, the closer we are to a tile 
						// boundary, which we'll shade to add detail to the walls
						vector<pair<float, float>> p;

						// Test each corner of hit tile, storing the distance from
						// the player, and the calculated dot product of the two rays
						for (int tx = 0; tx < 2; tx++)
							for (int ty = 0; ty < 2; ty++)
							{
								// Angle of corner to eye
								float vy = (float)nTestY + ty - fPlayerY;
								float vx = (float)nTestX + tx - fPlayerX;
								float d = sqrt(vx*vx + vy*vy); 
								float dot = (fEyeX * vx / d) + (fEyeY * vy / d);
								p.push_back(make_pair(d, dot));
							}

						// Sort Pairs from closest to farthest
						sort(p.begin(), p.end(), [](const pair<float, float> &left, const pair<float, float> &right) {return left.first < right.first; });
						
						// First two/three are closest (we will never see all four)
						float fBound = 0.01;
						if (acos(p.at(0).second) < fBound) bBoundary = true;
						if (acos(p.at(1).second) < fBound) bBoundary = true;
						if (acos(p.at(2).second) < fBound) bBoundary = true;
					}
				}
			}
		
			// Calculate distance to ceiling and floor
			int nCeiling = (float)(nScreenHeight/2.0) - nScreenHeight / ((float)fDistanceToWall);
			int nFloor = nScreenHeight - nCeiling;

			// Shader walls based on distance
			short nShade = ' ';
			if (fDistanceToWall <= fDepth / 4.0f)			nShade = 0x2588;	// Very close	
			else if (fDistanceToWall < fDepth / 3.0f)		nShade = 0x2593;
			else if (fDistanceToWall < fDepth / 2.0f)		nShade = 0x2592;
			else if (fDistanceToWall < fDepth)				nShade = 0x2591;
			else											nShade = ' ';		// Too far away

			if (bBoundary)		nShade = ' '; // Black it out
			
			for (int y = 0; y < nScreenHeight; y++)
			{
				// Each Row
				if(y <= nCeiling)
					screen[y*nScreenWidth + x] = ' ';
				else if(y > nCeiling && y <= nFloor)
					screen[y*nScreenWidth + x] = nShade;
				else // Floor
				{				
					// Shade floor based on distance
					float b = 1.0f - (((float)y -nScreenHeight/2.0f) / ((float)nScreenHeight / 2.0f));
					if (b < 0.25)		nShade = '#';
					else if (b < 0.5)	nShade = 'x';
					else if (b < 0.75)	nShade = '.';
					else if (b < 0.9)	nShade = '-';
					else				nShade = ' ';
					screen[y*nScreenWidth + x] = nShade;
				}
			}
		}

		// Display Stats
		swprintf_s(screen, 40, L"X=%3.2f, Y=%3.2f, A=%3.2f FPS=%3.2f ", fPlayerX, fPlayerY, fPlayerA, 1.0f/fElapsedTime);

		// Display Map
		for (int nx = 0; nx < nMapWidth; nx++)
			for (int ny = 0; ny < nMapWidth; ny++)
			{
				screen[(ny+1)*nScreenWidth + nx] = map[ny * nMapWidth + nx];
			}
		screen[((int)fPlayerX+1) * nScreenWidth + (int)fPlayerY] = 'P';

		// Display Frame
		screen[nScreenWidth * nScreenHeight - 1] = '\0';
		WriteConsoleOutputCharacter(hConsole, screen, nScreenWidth * nScreenHeight, { 0,0 }, &dwBytesWritten);
	}

	return 0;
}